1; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-keep-registers -wasm-disable-explicit-locals -mattr=+unimplemented-simd128 | FileCheck %s --check-prefixes CHECK,SIMD128 2; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-keep-registers -wasm-disable-explicit-locals -mattr=+simd128 | FileCheck %s 3; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-keep-registers -wasm-disable-explicit-locals | FileCheck %s --check-prefixes CHECK,NO-SIMD128 4 5; Test SIMD comparison operators 6 7target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" 8target triple = "wasm32-unknown-unknown" 9 10; CHECK-LABEL: compare_eq_v16i8: 11; NO-SIMD128-NOT: i8x16 12; SIMD128-NEXT: .functype compare_eq_v16i8 (v128, v128) -> (v128){{$}} 13; SIMD128-NEXT: i8x16.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 14; SIMD128-NEXT: return $pop[[R]]{{$}} 15define <16 x i1> @compare_eq_v16i8 (<16 x i8> %x, <16 x i8> %y) { 16 %res = icmp eq <16 x i8> %x, %y 17 ret <16 x i1> %res 18} 19 20; CHECK-LABEL: compare_sext_eq_v16i8: 21; NO-SIMD128-NOT: i8x16 22; SIMD128-NEXT: .functype compare_sext_eq_v16i8 (v128, v128) -> (v128){{$}} 23; SIMD128-NEXT: i8x16.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 24; SIMD128-NEXT: return $pop[[R]]{{$}} 25define <16 x i8> @compare_sext_eq_v16i8 (<16 x i8> %x, <16 x i8> %y) { 26 %cmp = icmp eq <16 x i8> %x, %y 27 %res = sext <16 x i1> %cmp to <16 x i8> 28 ret <16 x i8> %res 29} 30 31; CHECK-LABEL: compare_ne_v16i8: 32; NO-SIMD128-NOT: i8x16 33; SIMD128-NEXT: .functype compare_ne_v16i8 (v128, v128) -> (v128){{$}} 34; SIMD128-NEXT: i8x16.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 35; SIMD128-NEXT: return $pop[[R]]{{$}} 36define <16 x i1> @compare_ne_v16i8 (<16 x i8> %x, <16 x i8> %y) { 37 %res = icmp ne <16 x i8> %x, %y 38 ret <16 x i1> %res 39} 40 41; CHECK-LABEL: compare_sext_ne_v16i8: 42; NO-SIMD128-NOT: i8x16 43; SIMD128-NEXT: .functype compare_sext_ne_v16i8 (v128, v128) -> (v128){{$}} 44; SIMD128-NEXT: i8x16.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 45; SIMD128-NEXT: return $pop[[R]]{{$}} 46define <16 x i8> @compare_sext_ne_v16i8 (<16 x i8> %x, <16 x i8> %y) { 47 %cmp = icmp ne <16 x i8> %x, %y 48 %res = sext <16 x i1> %cmp to <16 x i8> 49 ret <16 x i8> %res 50} 51 52; CHECK-LABEL: compare_slt_v16i8: 53; NO-SIMD128-NOT: i8x16 54; SIMD128-NEXT: .functype compare_slt_v16i8 (v128, v128) -> (v128){{$}} 55; SIMD128-NEXT: i8x16.lt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 56; SIMD128-NEXT: return $pop[[R]]{{$}} 57define <16 x i1> @compare_slt_v16i8 (<16 x i8> %x, <16 x i8> %y) { 58 %res = icmp slt <16 x i8> %x, %y 59 ret <16 x i1> %res 60} 61 62; CHECK-LABEL: compare_sext_slt_v16i8: 63; NO-SIMD128-NOT: i8x16 64; SIMD128-NEXT: .functype compare_sext_slt_v16i8 (v128, v128) -> (v128){{$}} 65; SIMD128-NEXT: i8x16.lt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 66; SIMD128-NEXT: return $pop[[R]]{{$}} 67define <16 x i8> @compare_sext_slt_v16i8 (<16 x i8> %x, <16 x i8> %y) { 68 %cmp = icmp slt <16 x i8> %x, %y 69 %res = sext <16 x i1> %cmp to <16 x i8> 70 ret <16 x i8> %res 71} 72 73; CHECK-LABEL: compare_ult_v16i8: 74; NO-SIMD128-NOT: i8x16 75; SIMD128-NEXT: .functype compare_ult_v16i8 (v128, v128) -> (v128){{$}} 76; SIMD128-NEXT: i8x16.lt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 77; SIMD128-NEXT: return $pop[[R]]{{$}} 78define <16 x i1> @compare_ult_v16i8 (<16 x i8> %x, <16 x i8> %y) { 79 %res = icmp ult <16 x i8> %x, %y 80 ret <16 x i1> %res 81} 82 83; CHECK-LABEL: compare_sext_ult_v16i8: 84; NO-SIMD128-NOT: i8x16 85; SIMD128-NEXT: .functype compare_sext_ult_v16i8 (v128, v128) -> (v128){{$}} 86; SIMD128-NEXT: i8x16.lt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 87; SIMD128-NEXT: return $pop[[R]]{{$}} 88define <16 x i8> @compare_sext_ult_v16i8 (<16 x i8> %x, <16 x i8> %y) { 89 %cmp = icmp ult <16 x i8> %x, %y 90 %res = sext <16 x i1> %cmp to <16 x i8> 91 ret <16 x i8> %res 92} 93 94; CHECK-LABEL: compare_sle_v16i8: 95; NO-SIMD128-NOT: i8x16 96; SIMD128-NEXT: .functype compare_sle_v16i8 (v128, v128) -> (v128){{$}} 97; SIMD128-NEXT: i8x16.le_s $push[[R:[0-9]+]]=, $0, $1{{$}} 98; SIMD128-NEXT: return $pop[[R]]{{$}} 99define <16 x i1> @compare_sle_v16i8 (<16 x i8> %x, <16 x i8> %y) { 100 %res = icmp sle <16 x i8> %x, %y 101 ret <16 x i1> %res 102} 103 104; CHECK-LABEL: compare_sext_sle_v16i8: 105; NO-SIMD128-NOT: i8x16 106; SIMD128-NEXT: .functype compare_sext_sle_v16i8 (v128, v128) -> (v128){{$}} 107; SIMD128-NEXT: i8x16.le_s $push[[R:[0-9]+]]=, $0, $1{{$}} 108; SIMD128-NEXT: return $pop[[R]]{{$}} 109define <16 x i8> @compare_sext_sle_v16i8 (<16 x i8> %x, <16 x i8> %y) { 110 %cmp = icmp sle <16 x i8> %x, %y 111 %res = sext <16 x i1> %cmp to <16 x i8> 112 ret <16 x i8> %res 113} 114 115; CHECK-LABEL: compare_ule_v16i8: 116; NO-SIMD128-NOT: i8x16 117; SIMD128-NEXT: .functype compare_ule_v16i8 (v128, v128) -> (v128){{$}} 118; SIMD128-NEXT: i8x16.le_u $push[[R:[0-9]+]]=, $0, $1{{$}} 119; SIMD128-NEXT: return $pop[[R]]{{$}} 120define <16 x i1> @compare_ule_v16i8 (<16 x i8> %x, <16 x i8> %y) { 121 %res = icmp ule <16 x i8> %x, %y 122 ret <16 x i1> %res 123} 124 125; CHECK-LABEL: compare_sext_ule_v16i8: 126; NO-SIMD128-NOT: i8x16 127; SIMD128-NEXT: .functype compare_sext_ule_v16i8 (v128, v128) -> (v128){{$}} 128; SIMD128-NEXT: i8x16.le_u $push[[R:[0-9]+]]=, $0, $1{{$}} 129; SIMD128-NEXT: return $pop[[R]]{{$}} 130define <16 x i8> @compare_sext_ule_v16i8 (<16 x i8> %x, <16 x i8> %y) { 131 %cmp = icmp ule <16 x i8> %x, %y 132 %res = sext <16 x i1> %cmp to <16 x i8> 133 ret <16 x i8> %res 134} 135 136; CHECK-LABEL: compare_sgt_v16i8: 137; NO-SIMD128-NOT: i8x16 138; SIMD128-NEXT: .functype compare_sgt_v16i8 (v128, v128) -> (v128){{$}} 139; SIMD128-NEXT: i8x16.gt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 140; SIMD128-NEXT: return $pop[[R]]{{$}} 141define <16 x i1> @compare_sgt_v16i8 (<16 x i8> %x, <16 x i8> %y) { 142 %res = icmp sgt <16 x i8> %x, %y 143 ret <16 x i1> %res 144} 145 146; CHECK-LABEL: compare_sext_sgt_v16i8: 147; NO-SIMD128-NOT: i8x16 148; SIMD128-NEXT: .functype compare_sext_sgt_v16i8 (v128, v128) -> (v128){{$}} 149; SIMD128-NEXT: i8x16.gt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 150; SIMD128-NEXT: return $pop[[R]]{{$}} 151define <16 x i8> @compare_sext_sgt_v16i8 (<16 x i8> %x, <16 x i8> %y) { 152 %cmp = icmp sgt <16 x i8> %x, %y 153 %res = sext <16 x i1> %cmp to <16 x i8> 154 ret <16 x i8> %res 155} 156 157; CHECK-LABEL: compare_ugt_v16i8: 158; NO-SIMD128-NOT: i8x16 159; SIMD128-NEXT: .functype compare_ugt_v16i8 (v128, v128) -> (v128){{$}} 160; SIMD128-NEXT: i8x16.gt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 161; SIMD128-NEXT: return $pop[[R]]{{$}} 162define <16 x i1> @compare_ugt_v16i8 (<16 x i8> %x, <16 x i8> %y) { 163 %res = icmp ugt <16 x i8> %x, %y 164 ret <16 x i1> %res 165} 166 167; CHECK-LABEL: compare_sext_ugt_v16i8: 168; NO-SIMD128-NOT: i8x16 169; SIMD128-NEXT: .functype compare_sext_ugt_v16i8 (v128, v128) -> (v128){{$}} 170; SIMD128-NEXT: i8x16.gt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 171; SIMD128-NEXT: return $pop[[R]]{{$}} 172define <16 x i8> @compare_sext_ugt_v16i8 (<16 x i8> %x, <16 x i8> %y) { 173 %cmp = icmp ugt <16 x i8> %x, %y 174 %res = sext <16 x i1> %cmp to <16 x i8> 175 ret <16 x i8> %res 176} 177 178; CHECK-LABEL: compare_sge_v16i8: 179; NO-SIMD128-NOT: i8x16 180; SIMD128-NEXT: .functype compare_sge_v16i8 (v128, v128) -> (v128){{$}} 181; SIMD128-NEXT: i8x16.ge_s $push[[R:[0-9]+]]=, $0, $1{{$}} 182; SIMD128-NEXT: return $pop[[R]]{{$}} 183define <16 x i1> @compare_sge_v16i8 (<16 x i8> %x, <16 x i8> %y) { 184 %res = icmp sge <16 x i8> %x, %y 185 ret <16 x i1> %res 186} 187 188; CHECK-LABEL: compare_sext_sge_v16i8: 189; NO-SIMD128-NOT: i8x16 190; SIMD128-NEXT: .functype compare_sext_sge_v16i8 (v128, v128) -> (v128){{$}} 191; SIMD128-NEXT: i8x16.ge_s $push[[R:[0-9]+]]=, $0, $1{{$}} 192; SIMD128-NEXT: return $pop[[R]]{{$}} 193define <16 x i8> @compare_sext_sge_v16i8 (<16 x i8> %x, <16 x i8> %y) { 194 %cmp = icmp sge <16 x i8> %x, %y 195 %res = sext <16 x i1> %cmp to <16 x i8> 196 ret <16 x i8> %res 197} 198 199; CHECK-LABEL: compare_uge_v16i8: 200; NO-SIMD128-NOT: i8x16 201; SIMD128-NEXT: .functype compare_uge_v16i8 (v128, v128) -> (v128){{$}} 202; SIMD128-NEXT: i8x16.ge_u $push[[R:[0-9]+]]=, $0, $1{{$}} 203; SIMD128-NEXT: return $pop[[R]]{{$}} 204define <16 x i1> @compare_uge_v16i8 (<16 x i8> %x, <16 x i8> %y) { 205 %res = icmp uge <16 x i8> %x, %y 206 ret <16 x i1> %res 207} 208 209; CHECK-LABEL: compare_sext_uge_v16i8: 210; NO-SIMD128-NOT: i8x16 211; SIMD128-NEXT: .functype compare_sext_uge_v16i8 (v128, v128) -> (v128){{$}} 212; SIMD128-NEXT: i8x16.ge_u $push[[R:[0-9]+]]=, $0, $1{{$}} 213; SIMD128-NEXT: return $pop[[R]]{{$}} 214define <16 x i8> @compare_sext_uge_v16i8 (<16 x i8> %x, <16 x i8> %y) { 215 %cmp = icmp uge <16 x i8> %x, %y 216 %res = sext <16 x i1> %cmp to <16 x i8> 217 ret <16 x i8> %res 218} 219 220; CHECK-LABEL: compare_eq_v8i16: 221; NO-SIMD128-NOT: i16x8 222; SIMD128-NEXT: .functype compare_eq_v8i16 (v128, v128) -> (v128){{$}} 223; SIMD128-NEXT: i16x8.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 224; SIMD128-NEXT: return $pop[[R]]{{$}} 225define <8 x i1> @compare_eq_v8i16 (<8 x i16> %x, <8 x i16> %y) { 226 %res = icmp eq <8 x i16> %x, %y 227 ret <8 x i1> %res 228} 229 230; CHECK-LABEL: compare_sext_eq_v8i16: 231; NO-SIMD128-NOT: i16x8 232; SIMD128-NEXT: .functype compare_sext_eq_v8i16 (v128, v128) -> (v128){{$}} 233; SIMD128-NEXT: i16x8.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 234; SIMD128-NEXT: return $pop[[R]]{{$}} 235define <8 x i16> @compare_sext_eq_v8i16 (<8 x i16> %x, <8 x i16> %y) { 236 %cmp = icmp eq <8 x i16> %x, %y 237 %res = sext <8 x i1> %cmp to <8 x i16> 238 ret <8 x i16> %res 239} 240 241; CHECK-LABEL: compare_ne_v8i16: 242; NO-SIMD128-NOT: i16x8 243; SIMD128-NEXT: .functype compare_ne_v8i16 (v128, v128) -> (v128){{$}} 244; SIMD128-NEXT: i16x8.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 245; SIMD128-NEXT: return $pop[[R]]{{$}} 246define <8 x i1> @compare_ne_v8i16 (<8 x i16> %x, <8 x i16> %y) { 247 %res = icmp ne <8 x i16> %x, %y 248 ret <8 x i1> %res 249} 250 251; CHECK-LABEL: compare_sext_ne_v8i16: 252; NO-SIMD128-NOT: i16x8 253; SIMD128-NEXT: .functype compare_sext_ne_v8i16 (v128, v128) -> (v128){{$}} 254; SIMD128-NEXT: i16x8.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 255; SIMD128-NEXT: return $pop[[R]]{{$}} 256define <8 x i16> @compare_sext_ne_v8i16 (<8 x i16> %x, <8 x i16> %y) { 257 %cmp = icmp ne <8 x i16> %x, %y 258 %res = sext <8 x i1> %cmp to <8 x i16> 259 ret <8 x i16> %res 260} 261 262; CHECK-LABEL: compare_slt_v8i16: 263; NO-SIMD128-NOT: i16x8 264; SIMD128-NEXT: .functype compare_slt_v8i16 (v128, v128) -> (v128){{$}} 265; SIMD128-NEXT: i16x8.lt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 266; SIMD128-NEXT: return $pop[[R]]{{$}} 267define <8 x i1> @compare_slt_v8i16 (<8 x i16> %x, <8 x i16> %y) { 268 %res = icmp slt <8 x i16> %x, %y 269 ret <8 x i1> %res 270} 271 272; CHECK-LABEL: compare_sext_slt_v8i16: 273; NO-SIMD128-NOT: i16x8 274; SIMD128-NEXT: .functype compare_sext_slt_v8i16 (v128, v128) -> (v128){{$}} 275; SIMD128-NEXT: i16x8.lt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 276; SIMD128-NEXT: return $pop[[R]]{{$}} 277define <8 x i16> @compare_sext_slt_v8i16 (<8 x i16> %x, <8 x i16> %y) { 278 %cmp = icmp slt <8 x i16> %x, %y 279 %res = sext <8 x i1> %cmp to <8 x i16> 280 ret <8 x i16> %res 281} 282 283; CHECK-LABEL: compare_ult_v8i16: 284; NO-SIMD128-NOT: i16x8 285; SIMD128-NEXT: .functype compare_ult_v8i16 (v128, v128) -> (v128){{$}} 286; SIMD128-NEXT: i16x8.lt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 287; SIMD128-NEXT: return $pop[[R]]{{$}} 288define <8 x i1> @compare_ult_v8i16 (<8 x i16> %x, <8 x i16> %y) { 289 %res = icmp ult <8 x i16> %x, %y 290 ret <8 x i1> %res 291} 292 293; CHECK-LABEL: compare_sext_ult_v8i16: 294; NO-SIMD128-NOT: i16x8 295; SIMD128-NEXT: .functype compare_sext_ult_v8i16 (v128, v128) -> (v128){{$}} 296; SIMD128-NEXT: i16x8.lt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 297; SIMD128-NEXT: return $pop[[R]]{{$}} 298define <8 x i16> @compare_sext_ult_v8i16 (<8 x i16> %x, <8 x i16> %y) { 299 %cmp = icmp ult <8 x i16> %x, %y 300 %res = sext <8 x i1> %cmp to <8 x i16> 301 ret <8 x i16> %res 302} 303 304; CHECK-LABEL: compare_sle_v8i16: 305; NO-SIMD128-NOT: i16x8 306; SIMD128-NEXT: .functype compare_sle_v8i16 (v128, v128) -> (v128){{$}} 307; SIMD128-NEXT: i16x8.le_s $push[[R:[0-9]+]]=, $0, $1{{$}} 308; SIMD128-NEXT: return $pop[[R]]{{$}} 309define <8 x i1> @compare_sle_v8i16 (<8 x i16> %x, <8 x i16> %y) { 310 %res = icmp sle <8 x i16> %x, %y 311 ret <8 x i1> %res 312} 313 314; CHECK-LABEL: compare_sext_sle_v8i16: 315; NO-SIMD128-NOT: i16x8 316; SIMD128-NEXT: .functype compare_sext_sle_v8i16 (v128, v128) -> (v128){{$}} 317; SIMD128-NEXT: i16x8.le_s $push[[R:[0-9]+]]=, $0, $1{{$}} 318; SIMD128-NEXT: return $pop[[R]]{{$}} 319define <8 x i16> @compare_sext_sle_v8i16 (<8 x i16> %x, <8 x i16> %y) { 320 %cmp = icmp sle <8 x i16> %x, %y 321 %res = sext <8 x i1> %cmp to <8 x i16> 322 ret <8 x i16> %res 323} 324 325; CHECK-LABEL: compare_ule_v8i16: 326; NO-SIMD128-NOT: i16x8 327; SIMD128-NEXT: .functype compare_ule_v8i16 (v128, v128) -> (v128){{$}} 328; SIMD128-NEXT: i16x8.le_u $push[[R:[0-9]+]]=, $0, $1{{$}} 329; SIMD128-NEXT: return $pop[[R]]{{$}} 330define <8 x i1> @compare_ule_v8i16 (<8 x i16> %x, <8 x i16> %y) { 331 %res = icmp ule <8 x i16> %x, %y 332 ret <8 x i1> %res 333} 334 335; CHECK-LABEL: compare_sext_ule_v8i16: 336; NO-SIMD128-NOT: i16x8 337; SIMD128-NEXT: .functype compare_sext_ule_v8i16 (v128, v128) -> (v128){{$}} 338; SIMD128-NEXT: i16x8.le_u $push[[R:[0-9]+]]=, $0, $1{{$}} 339; SIMD128-NEXT: return $pop[[R]]{{$}} 340define <8 x i16> @compare_sext_ule_v8i16 (<8 x i16> %x, <8 x i16> %y) { 341 %cmp = icmp ule <8 x i16> %x, %y 342 %res = sext <8 x i1> %cmp to <8 x i16> 343 ret <8 x i16> %res 344} 345 346; CHECK-LABEL: compare_sgt_v8i16: 347; NO-SIMD128-NOT: i16x8 348; SIMD128-NEXT: .functype compare_sgt_v8i16 (v128, v128) -> (v128){{$}} 349; SIMD128-NEXT: i16x8.gt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 350; SIMD128-NEXT: return $pop[[R]]{{$}} 351define <8 x i1> @compare_sgt_v8i16 (<8 x i16> %x, <8 x i16> %y) { 352 %res = icmp sgt <8 x i16> %x, %y 353 ret <8 x i1> %res 354} 355 356; CHECK-LABEL: compare_sext_sgt_v8i16: 357; NO-SIMD128-NOT: i16x8 358; SIMD128-NEXT: .functype compare_sext_sgt_v8i16 (v128, v128) -> (v128){{$}} 359; SIMD128-NEXT: i16x8.gt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 360; SIMD128-NEXT: return $pop[[R]]{{$}} 361define <8 x i16> @compare_sext_sgt_v8i16 (<8 x i16> %x, <8 x i16> %y) { 362 %cmp = icmp sgt <8 x i16> %x, %y 363 %res = sext <8 x i1> %cmp to <8 x i16> 364 ret <8 x i16> %res 365} 366 367; CHECK-LABEL: compare_ugt_v8i16: 368; NO-SIMD128-NOT: i16x8 369; SIMD128-NEXT: .functype compare_ugt_v8i16 (v128, v128) -> (v128){{$}} 370; SIMD128-NEXT: i16x8.gt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 371; SIMD128-NEXT: return $pop[[R]]{{$}} 372define <8 x i1> @compare_ugt_v8i16 (<8 x i16> %x, <8 x i16> %y) { 373 %res = icmp ugt <8 x i16> %x, %y 374 ret <8 x i1> %res 375} 376 377; CHECK-LABEL: compare_sext_ugt_v8i16: 378; NO-SIMD128-NOT: i16x8 379; SIMD128-NEXT: .functype compare_sext_ugt_v8i16 (v128, v128) -> (v128){{$}} 380; SIMD128-NEXT: i16x8.gt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 381; SIMD128-NEXT: return $pop[[R]]{{$}} 382define <8 x i16> @compare_sext_ugt_v8i16 (<8 x i16> %x, <8 x i16> %y) { 383 %cmp = icmp ugt <8 x i16> %x, %y 384 %res = sext <8 x i1> %cmp to <8 x i16> 385 ret <8 x i16> %res 386} 387 388; CHECK-LABEL: compare_sge_v8i16: 389; NO-SIMD128-NOT: i16x8 390; SIMD128-NEXT: .functype compare_sge_v8i16 (v128, v128) -> (v128){{$}} 391; SIMD128-NEXT: i16x8.ge_s $push[[R:[0-9]+]]=, $0, $1{{$}} 392; SIMD128-NEXT: return $pop[[R]]{{$}} 393define <8 x i1> @compare_sge_v8i16 (<8 x i16> %x, <8 x i16> %y) { 394 %res = icmp sge <8 x i16> %x, %y 395 ret <8 x i1> %res 396} 397 398; CHECK-LABEL: compare_sext_sge_v8i16: 399; NO-SIMD128-NOT: i16x8 400; SIMD128-NEXT: .functype compare_sext_sge_v8i16 (v128, v128) -> (v128){{$}} 401; SIMD128-NEXT: i16x8.ge_s $push[[R:[0-9]+]]=, $0, $1{{$}} 402; SIMD128-NEXT: return $pop[[R]]{{$}} 403define <8 x i16> @compare_sext_sge_v8i16 (<8 x i16> %x, <8 x i16> %y) { 404 %cmp = icmp sge <8 x i16> %x, %y 405 %res = sext <8 x i1> %cmp to <8 x i16> 406 ret <8 x i16> %res 407} 408 409; CHECK-LABEL: compare_uge_v8i16: 410; NO-SIMD128-NOT: i16x8 411; SIMD128-NEXT: .functype compare_uge_v8i16 (v128, v128) -> (v128){{$}} 412; SIMD128-NEXT: i16x8.ge_u $push[[R:[0-9]+]]=, $0, $1{{$}} 413; SIMD128-NEXT: return $pop[[R]]{{$}} 414define <8 x i1> @compare_uge_v8i16 (<8 x i16> %x, <8 x i16> %y) { 415 %res = icmp uge <8 x i16> %x, %y 416 ret <8 x i1> %res 417} 418 419; CHECK-LABEL: compare_sext_uge_v8i16: 420; NO-SIMD128-NOT: i16x8 421; SIMD128-NEXT: .functype compare_sext_uge_v8i16 (v128, v128) -> (v128){{$}} 422; SIMD128-NEXT: i16x8.ge_u $push[[R:[0-9]+]]=, $0, $1{{$}} 423; SIMD128-NEXT: return $pop[[R]]{{$}} 424define <8 x i16> @compare_sext_uge_v8i16 (<8 x i16> %x, <8 x i16> %y) { 425 %cmp = icmp uge <8 x i16> %x, %y 426 %res = sext <8 x i1> %cmp to <8 x i16> 427 ret <8 x i16> %res 428} 429 430; CHECK-LABEL: compare_eq_v4i32: 431; NO-SIMD128-NOT: i32x4 432; SIMD128-NEXT: .functype compare_eq_v4i32 (v128, v128) -> (v128){{$}} 433; SIMD128-NEXT: i32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 434; SIMD128-NEXT: return $pop[[R]]{{$}} 435define <4 x i1> @compare_eq_v4i32 (<4 x i32> %x, <4 x i32> %y) { 436 %res = icmp eq <4 x i32> %x, %y 437 ret <4 x i1> %res 438} 439 440; CHECK-LABEL: compare_sext_eq_v4i32: 441; NO-SIMD128-NOT: i32x4 442; SIMD128-NEXT: .functype compare_sext_eq_v4i32 (v128, v128) -> (v128){{$}} 443; SIMD128-NEXT: i32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 444; SIMD128-NEXT: return $pop[[R]]{{$}} 445define <4 x i32> @compare_sext_eq_v4i32 (<4 x i32> %x, <4 x i32> %y) { 446 %cmp = icmp eq <4 x i32> %x, %y 447 %res = sext <4 x i1> %cmp to <4 x i32> 448 ret <4 x i32> %res 449} 450 451; CHECK-LABEL: compare_ne_v4i32: 452; NO-SIMD128-NOT: i32x4 453; SIMD128-NEXT: .functype compare_ne_v4i32 (v128, v128) -> (v128){{$}} 454; SIMD128-NEXT: i32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 455; SIMD128-NEXT: return $pop[[R]]{{$}} 456define <4 x i1> @compare_ne_v4i32 (<4 x i32> %x, <4 x i32> %y) { 457 %res = icmp ne <4 x i32> %x, %y 458 ret <4 x i1> %res 459} 460 461; CHECK-LABEL: compare_sext_ne_v4i32: 462; NO-SIMD128-NOT: i32x4 463; SIMD128-NEXT: .functype compare_sext_ne_v4i32 (v128, v128) -> (v128){{$}} 464; SIMD128-NEXT: i32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 465; SIMD128-NEXT: return $pop[[R]]{{$}} 466define <4 x i32> @compare_sext_ne_v4i32 (<4 x i32> %x, <4 x i32> %y) { 467 %cmp = icmp ne <4 x i32> %x, %y 468 %res = sext <4 x i1> %cmp to <4 x i32> 469 ret <4 x i32> %res 470} 471 472; CHECK-LABEL: compare_slt_v4i32: 473; NO-SIMD128-NOT: i32x4 474; SIMD128-NEXT: .functype compare_slt_v4i32 (v128, v128) -> (v128){{$}} 475; SIMD128-NEXT: i32x4.lt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 476; SIMD128-NEXT: return $pop[[R]]{{$}} 477define <4 x i1> @compare_slt_v4i32 (<4 x i32> %x, <4 x i32> %y) { 478 %res = icmp slt <4 x i32> %x, %y 479 ret <4 x i1> %res 480} 481 482; CHECK-LABEL: compare_sext_slt_v4i32: 483; NO-SIMD128-NOT: i32x4 484; SIMD128-NEXT: .functype compare_sext_slt_v4i32 (v128, v128) -> (v128){{$}} 485; SIMD128-NEXT: i32x4.lt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 486; SIMD128-NEXT: return $pop[[R]]{{$}} 487define <4 x i32> @compare_sext_slt_v4i32 (<4 x i32> %x, <4 x i32> %y) { 488 %cmp = icmp slt <4 x i32> %x, %y 489 %res = sext <4 x i1> %cmp to <4 x i32> 490 ret <4 x i32> %res 491} 492 493; CHECK-LABEL: compare_ult_v4i32: 494; NO-SIMD128-NOT: i32x4 495; SIMD128-NEXT: .functype compare_ult_v4i32 (v128, v128) -> (v128){{$}} 496; SIMD128-NEXT: i32x4.lt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 497; SIMD128-NEXT: return $pop[[R]]{{$}} 498define <4 x i1> @compare_ult_v4i32 (<4 x i32> %x, <4 x i32> %y) { 499 %res = icmp ult <4 x i32> %x, %y 500 ret <4 x i1> %res 501} 502 503; CHECK-LABEL: compare_sext_ult_v4i32: 504; NO-SIMD128-NOT: i32x4 505; SIMD128-NEXT: .functype compare_sext_ult_v4i32 (v128, v128) -> (v128){{$}} 506; SIMD128-NEXT: i32x4.lt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 507; SIMD128-NEXT: return $pop[[R]]{{$}} 508define <4 x i32> @compare_sext_ult_v4i32 (<4 x i32> %x, <4 x i32> %y) { 509 %cmp = icmp ult <4 x i32> %x, %y 510 %res = sext <4 x i1> %cmp to <4 x i32> 511 ret <4 x i32> %res 512} 513 514; CHECK-LABEL: compare_sle_v4i32: 515; NO-SIMD128-NOT: i32x4 516; SIMD128-NEXT: .functype compare_sle_v4i32 (v128, v128) -> (v128){{$}} 517; SIMD128-NEXT: i32x4.le_s $push[[R:[0-9]+]]=, $0, $1{{$}} 518; SIMD128-NEXT: return $pop[[R]]{{$}} 519define <4 x i1> @compare_sle_v4i32 (<4 x i32> %x, <4 x i32> %y) { 520 %res = icmp sle <4 x i32> %x, %y 521 ret <4 x i1> %res 522} 523 524; CHECK-LABEL: compare_sext_sle_v4i32: 525; NO-SIMD128-NOT: i32x4 526; SIMD128-NEXT: .functype compare_sext_sle_v4i32 (v128, v128) -> (v128){{$}} 527; SIMD128-NEXT: i32x4.le_s $push[[R:[0-9]+]]=, $0, $1{{$}} 528; SIMD128-NEXT: return $pop[[R]]{{$}} 529define <4 x i32> @compare_sext_sle_v4i32 (<4 x i32> %x, <4 x i32> %y) { 530 %cmp = icmp sle <4 x i32> %x, %y 531 %res = sext <4 x i1> %cmp to <4 x i32> 532 ret <4 x i32> %res 533} 534 535; CHECK-LABEL: compare_ule_v4i32: 536; NO-SIMD128-NOT: i32x4 537; SIMD128-NEXT: .functype compare_ule_v4i32 (v128, v128) -> (v128){{$}} 538; SIMD128-NEXT: i32x4.le_u $push[[R:[0-9]+]]=, $0, $1{{$}} 539; SIMD128-NEXT: return $pop[[R]]{{$}} 540define <4 x i1> @compare_ule_v4i32 (<4 x i32> %x, <4 x i32> %y) { 541 %res = icmp ule <4 x i32> %x, %y 542 ret <4 x i1> %res 543} 544 545; CHECK-LABEL: compare_sext_ule_v4i32: 546; NO-SIMD128-NOT: i32x4 547; SIMD128-NEXT: .functype compare_sext_ule_v4i32 (v128, v128) -> (v128){{$}} 548; SIMD128-NEXT: i32x4.le_u $push[[R:[0-9]+]]=, $0, $1{{$}} 549; SIMD128-NEXT: return $pop[[R]]{{$}} 550define <4 x i32> @compare_sext_ule_v4i32 (<4 x i32> %x, <4 x i32> %y) { 551 %cmp = icmp ule <4 x i32> %x, %y 552 %res = sext <4 x i1> %cmp to <4 x i32> 553 ret <4 x i32> %res 554} 555 556; CHECK-LABEL: compare_sgt_v4i32: 557; NO-SIMD128-NOT: i32x4 558; SIMD128-NEXT: .functype compare_sgt_v4i32 (v128, v128) -> (v128){{$}} 559; SIMD128-NEXT: i32x4.gt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 560; SIMD128-NEXT: return $pop[[R]]{{$}} 561define <4 x i1> @compare_sgt_v4i32 (<4 x i32> %x, <4 x i32> %y) { 562 %res = icmp sgt <4 x i32> %x, %y 563 ret <4 x i1> %res 564} 565 566; CHECK-LABEL: compare_sext_sgt_v4i32: 567; NO-SIMD128-NOT: i32x4 568; SIMD128-NEXT: .functype compare_sext_sgt_v4i32 (v128, v128) -> (v128){{$}} 569; SIMD128-NEXT: i32x4.gt_s $push[[R:[0-9]+]]=, $0, $1{{$}} 570; SIMD128-NEXT: return $pop[[R]]{{$}} 571define <4 x i32> @compare_sext_sgt_v4i32 (<4 x i32> %x, <4 x i32> %y) { 572 %cmp = icmp sgt <4 x i32> %x, %y 573 %res = sext <4 x i1> %cmp to <4 x i32> 574 ret <4 x i32> %res 575} 576 577; CHECK-LABEL: compare_ugt_v4i32: 578; NO-SIMD128-NOT: i32x4 579; SIMD128-NEXT: .functype compare_ugt_v4i32 (v128, v128) -> (v128){{$}} 580; SIMD128-NEXT: i32x4.gt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 581; SIMD128-NEXT: return $pop[[R]]{{$}} 582define <4 x i1> @compare_ugt_v4i32 (<4 x i32> %x, <4 x i32> %y) { 583 %res = icmp ugt <4 x i32> %x, %y 584 ret <4 x i1> %res 585} 586 587; CHECK-LABEL: compare_sext_ugt_v4i32: 588; NO-SIMD128-NOT: i32x4 589; SIMD128-NEXT: .functype compare_sext_ugt_v4i32 (v128, v128) -> (v128){{$}} 590; SIMD128-NEXT: i32x4.gt_u $push[[R:[0-9]+]]=, $0, $1{{$}} 591; SIMD128-NEXT: return $pop[[R]]{{$}} 592define <4 x i32> @compare_sext_ugt_v4i32 (<4 x i32> %x, <4 x i32> %y) { 593 %cmp = icmp ugt <4 x i32> %x, %y 594 %res = sext <4 x i1> %cmp to <4 x i32> 595 ret <4 x i32> %res 596} 597 598; CHECK-LABEL: compare_sge_v4i32: 599; NO-SIMD128-NOT: i32x4 600; SIMD128-NEXT: .functype compare_sge_v4i32 (v128, v128) -> (v128){{$}} 601; SIMD128-NEXT: i32x4.ge_s $push[[R:[0-9]+]]=, $0, $1{{$}} 602; SIMD128-NEXT: return $pop[[R]]{{$}} 603define <4 x i1> @compare_sge_v4i32 (<4 x i32> %x, <4 x i32> %y) { 604 %res = icmp sge <4 x i32> %x, %y 605 ret <4 x i1> %res 606} 607 608; CHECK-LABEL: compare_sext_sge_v4i32: 609; NO-SIMD128-NOT: i32x4 610; SIMD128-NEXT: .functype compare_sext_sge_v4i32 (v128, v128) -> (v128){{$}} 611; SIMD128-NEXT: i32x4.ge_s $push[[R:[0-9]+]]=, $0, $1{{$}} 612; SIMD128-NEXT: return $pop[[R]]{{$}} 613define <4 x i32> @compare_sext_sge_v4i32 (<4 x i32> %x, <4 x i32> %y) { 614 %cmp = icmp sge <4 x i32> %x, %y 615 %res = sext <4 x i1> %cmp to <4 x i32> 616 ret <4 x i32> %res 617} 618 619; CHECK-LABEL: compare_uge_v4i32: 620; NO-SIMD128-NOT: i32x4 621; SIMD128-NEXT: .functype compare_uge_v4i32 (v128, v128) -> (v128){{$}} 622; SIMD128-NEXT: i32x4.ge_u $push[[R:[0-9]+]]=, $0, $1{{$}} 623; SIMD128-NEXT: return $pop[[R]]{{$}} 624define <4 x i1> @compare_uge_v4i32 (<4 x i32> %x, <4 x i32> %y) { 625 %res = icmp uge <4 x i32> %x, %y 626 ret <4 x i1> %res 627} 628 629; CHECK-LABEL: compare_sext_uge_v4i32: 630; NO-SIMD128-NOT: i32x4 631; SIMD128-NEXT: .functype compare_sext_uge_v4i32 (v128, v128) -> (v128){{$}} 632; SIMD128-NEXT: i32x4.ge_u $push[[R:[0-9]+]]=, $0, $1{{$}} 633; SIMD128-NEXT: return $pop[[R]]{{$}} 634define <4 x i32> @compare_sext_uge_v4i32 (<4 x i32> %x, <4 x i32> %y) { 635 %cmp = icmp uge <4 x i32> %x, %y 636 %res = sext <4 x i1> %cmp to <4 x i32> 637 ret <4 x i32> %res 638} 639 640; CHECK-LABEL: compare_eq_v2i64: 641; SIMD128-NEXT: .functype compare_eq_v2i64 (v128, v128) -> (v128){{$}} 642define <2 x i1> @compare_eq_v2i64 (<2 x i64> %x, <2 x i64> %y) { 643 %res = icmp eq <2 x i64> %x, %y 644 ret <2 x i1> %res 645} 646 647; CHECK-LABEL: compare_sext_eq_v2i64: 648; SIMD128-NEXT: .functype compare_sext_eq_v2i64 (v128, v128) -> (v128){{$}} 649define <2 x i64> @compare_sext_eq_v2i64 (<2 x i64> %x, <2 x i64> %y) { 650 %cmp = icmp eq <2 x i64> %x, %y 651 %res = sext <2 x i1> %cmp to <2 x i64> 652 ret <2 x i64> %res 653} 654 655; CHECK-LABEL: compare_ne_v2i64: 656; SIMD128-NEXT: .functype compare_ne_v2i64 (v128, v128) -> (v128){{$}} 657define <2 x i1> @compare_ne_v2i64 (<2 x i64> %x, <2 x i64> %y) { 658 %res = icmp ne <2 x i64> %x, %y 659 ret <2 x i1> %res 660} 661 662; CHECK-LABEL: compare_sext_ne_v2i64: 663; SIMD128-NEXT: .functype compare_sext_ne_v2i64 (v128, v128) -> (v128){{$}} 664define <2 x i64> @compare_sext_ne_v2i64 (<2 x i64> %x, <2 x i64> %y) { 665 %cmp = icmp ne <2 x i64> %x, %y 666 %res = sext <2 x i1> %cmp to <2 x i64> 667 ret <2 x i64> %res 668} 669 670; CHECK-LABEL: compare_slt_v2i64: 671; SIMD128-NEXT: .functype compare_slt_v2i64 (v128, v128) -> (v128){{$}} 672define <2 x i1> @compare_slt_v2i64 (<2 x i64> %x, <2 x i64> %y) { 673 %res = icmp slt <2 x i64> %x, %y 674 ret <2 x i1> %res 675} 676 677; CHECK-LABEL: compare_sext_slt_v2i64: 678; SIMD128-NEXT: .functype compare_sext_slt_v2i64 (v128, v128) -> (v128){{$}} 679define <2 x i64> @compare_sext_slt_v2i64 (<2 x i64> %x, <2 x i64> %y) { 680 %cmp = icmp slt <2 x i64> %x, %y 681 %res = sext <2 x i1> %cmp to <2 x i64> 682 ret <2 x i64> %res 683} 684 685; CHECK-LABEL: compare_ult_v2i64: 686; SIMD128-NEXT: .functype compare_ult_v2i64 (v128, v128) -> (v128){{$}} 687define <2 x i1> @compare_ult_v2i64 (<2 x i64> %x, <2 x i64> %y) { 688 %res = icmp ult <2 x i64> %x, %y 689 ret <2 x i1> %res 690} 691 692; CHECK-LABEL: compare_sext_ult_v2i64: 693; SIMD128-NEXT: .functype compare_sext_ult_v2i64 (v128, v128) -> (v128){{$}} 694define <2 x i64> @compare_sext_ult_v2i64 (<2 x i64> %x, <2 x i64> %y) { 695 %cmp = icmp ult <2 x i64> %x, %y 696 %res = sext <2 x i1> %cmp to <2 x i64> 697 ret <2 x i64> %res 698} 699 700; CHECK-LABEL: compare_sle_v2i64: 701; SIMD128-NEXT: .functype compare_sle_v2i64 (v128, v128) -> (v128){{$}} 702define <2 x i1> @compare_sle_v2i64 (<2 x i64> %x, <2 x i64> %y) { 703 %res = icmp sle <2 x i64> %x, %y 704 ret <2 x i1> %res 705} 706 707; CHECK-LABEL: compare_sext_sle_v2i64: 708; SIMD128-NEXT: .functype compare_sext_sle_v2i64 (v128, v128) -> (v128){{$}} 709define <2 x i64> @compare_sext_sle_v2i64 (<2 x i64> %x, <2 x i64> %y) { 710 %cmp = icmp sle <2 x i64> %x, %y 711 %res = sext <2 x i1> %cmp to <2 x i64> 712 ret <2 x i64> %res 713} 714 715; CHECK-LABEL: compare_ule_v2i64: 716; SIMD128-NEXT: .functype compare_ule_v2i64 (v128, v128) -> (v128){{$}} 717define <2 x i1> @compare_ule_v2i64 (<2 x i64> %x, <2 x i64> %y) { 718 %res = icmp ule <2 x i64> %x, %y 719 ret <2 x i1> %res 720} 721 722; CHECK-LABEL: compare_sext_ule_v2i64: 723; SIMD128-NEXT: .functype compare_sext_ule_v2i64 (v128, v128) -> (v128){{$}} 724define <2 x i64> @compare_sext_ule_v2i64 (<2 x i64> %x, <2 x i64> %y) { 725 %cmp = icmp ule <2 x i64> %x, %y 726 %res = sext <2 x i1> %cmp to <2 x i64> 727 ret <2 x i64> %res 728} 729 730; CHECK-LABEL: compare_sgt_v2i64: 731; SIMD128-NEXT: .functype compare_sgt_v2i64 (v128, v128) -> (v128){{$}} 732define <2 x i1> @compare_sgt_v2i64 (<2 x i64> %x, <2 x i64> %y) { 733 %res = icmp sgt <2 x i64> %x, %y 734 ret <2 x i1> %res 735} 736 737; CHECK-LABEL: compare_sext_sgt_v2i64: 738; SIMD128-NEXT: .functype compare_sext_sgt_v2i64 (v128, v128) -> (v128){{$}} 739define <2 x i64> @compare_sext_sgt_v2i64 (<2 x i64> %x, <2 x i64> %y) { 740 %cmp = icmp sgt <2 x i64> %x, %y 741 %res = sext <2 x i1> %cmp to <2 x i64> 742 ret <2 x i64> %res 743} 744 745; CHECK-LABEL: compare_ugt_v2i64: 746; SIMD128-NEXT: .functype compare_ugt_v2i64 (v128, v128) -> (v128){{$}} 747define <2 x i1> @compare_ugt_v2i64 (<2 x i64> %x, <2 x i64> %y) { 748 %res = icmp ugt <2 x i64> %x, %y 749 ret <2 x i1> %res 750} 751 752; CHECK-LABEL: compare_sext_ugt_v2i64: 753; SIMD128-NEXT: .functype compare_sext_ugt_v2i64 (v128, v128) -> (v128){{$}} 754define <2 x i64> @compare_sext_ugt_v2i64 (<2 x i64> %x, <2 x i64> %y) { 755 %cmp = icmp ugt <2 x i64> %x, %y 756 %res = sext <2 x i1> %cmp to <2 x i64> 757 ret <2 x i64> %res 758} 759 760; CHECK-LABEL: compare_sge_v2i64: 761; SIMD128-NEXT: .functype compare_sge_v2i64 (v128, v128) -> (v128){{$}} 762define <2 x i1> @compare_sge_v2i64 (<2 x i64> %x, <2 x i64> %y) { 763 %res = icmp sge <2 x i64> %x, %y 764 ret <2 x i1> %res 765} 766 767; CHECK-LABEL: compare_sext_sge_v2i64: 768; SIMD128-NEXT: .functype compare_sext_sge_v2i64 (v128, v128) -> (v128){{$}} 769define <2 x i64> @compare_sext_sge_v2i64 (<2 x i64> %x, <2 x i64> %y) { 770 %cmp = icmp sge <2 x i64> %x, %y 771 %res = sext <2 x i1> %cmp to <2 x i64> 772 ret <2 x i64> %res 773} 774 775; CHECK-LABEL: compare_uge_v2i64: 776; SIMD128-NEXT: .functype compare_uge_v2i64 (v128, v128) -> (v128){{$}} 777define <2 x i1> @compare_uge_v2i64 (<2 x i64> %x, <2 x i64> %y) { 778 %res = icmp uge <2 x i64> %x, %y 779 ret <2 x i1> %res 780} 781 782; CHECK-LABEL: compare_sext_uge_v2i64: 783; SIMD128-NEXT: .functype compare_sext_uge_v2i64 (v128, v128) -> (v128){{$}} 784define <2 x i64> @compare_sext_uge_v2i64 (<2 x i64> %x, <2 x i64> %y) { 785 %cmp = icmp uge <2 x i64> %x, %y 786 %res = sext <2 x i1> %cmp to <2 x i64> 787 ret <2 x i64> %res 788} 789 790; CHECK-LABEL: compare_oeq_v4f32: 791; NO-SIMD128-NOT: f32x4 792; SIMD128-NEXT: .functype compare_oeq_v4f32 (v128, v128) -> (v128){{$}} 793; SIMD128-NEXT: f32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 794; SIMD128-NEXT: return $pop[[R]]{{$}} 795define <4 x i1> @compare_oeq_v4f32 (<4 x float> %x, <4 x float> %y) { 796 %res = fcmp oeq <4 x float> %x, %y 797 ret <4 x i1> %res 798} 799 800; CHECK-LABEL: compare_oeq_nnan_v4f32: 801; NO-SIMD128-NOT: f32x4 802; SIMD128-NEXT: .functype compare_oeq_nnan_v4f32 (v128, v128) -> (v128){{$}} 803; SIMD128-NEXT: f32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 804; SIMD128-NEXT: return $pop[[R]]{{$}} 805define <4 x i1> @compare_oeq_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 806 %res = fcmp nnan oeq <4 x float> %x, %y 807 ret <4 x i1> %res 808} 809 810; CHECK-LABEL: compare_sext_oeq_v4f32: 811; NO-SIMD128-NOT: f32x4 812; SIMD128-NEXT: .functype compare_sext_oeq_v4f32 (v128, v128) -> (v128){{$}} 813; SIMD128-NEXT: f32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 814; SIMD128-NEXT: return $pop[[R]]{{$}} 815define <4 x i32> @compare_sext_oeq_v4f32 (<4 x float> %x, <4 x float> %y) { 816 %cmp = fcmp oeq <4 x float> %x, %y 817 %res = sext <4 x i1> %cmp to <4 x i32> 818 ret <4 x i32> %res 819} 820 821; CHECK-LABEL: compare_sext_oeq_nnan_v4f32: 822; NO-SIMD128-NOT: f32x4 823; SIMD128-NEXT: .functype compare_sext_oeq_nnan_v4f32 (v128, v128) -> (v128){{$}} 824; SIMD128-NEXT: f32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 825; SIMD128-NEXT: return $pop[[R]]{{$}} 826define <4 x i32> @compare_sext_oeq_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 827 %cmp = fcmp nnan oeq <4 x float> %x, %y 828 %res = sext <4 x i1> %cmp to <4 x i32> 829 ret <4 x i32> %res 830} 831 832; CHECK-LABEL: compare_ogt_v4f32: 833; NO-SIMD128-NOT: f32x4 834; SIMD128-NEXT: .functype compare_ogt_v4f32 (v128, v128) -> (v128){{$}} 835; SIMD128-NEXT: f32x4.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 836; SIMD128-NEXT: return $pop[[R]]{{$}} 837define <4 x i1> @compare_ogt_v4f32 (<4 x float> %x, <4 x float> %y) { 838 %res = fcmp ogt <4 x float> %x, %y 839 ret <4 x i1> %res 840} 841 842; CHECK-LABEL: compare_ogt_nnan_v4f32: 843; NO-SIMD128-NOT: f32x4 844; SIMD128-NEXT: .functype compare_ogt_nnan_v4f32 (v128, v128) -> (v128){{$}} 845; SIMD128-NEXT: f32x4.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 846; SIMD128-NEXT: return $pop[[R]]{{$}} 847define <4 x i1> @compare_ogt_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 848 %res = fcmp nnan ogt <4 x float> %x, %y 849 ret <4 x i1> %res 850} 851 852; CHECK-LABEL: compare_sext_ogt_v4f32: 853; NO-SIMD128-NOT: f32x4 854; SIMD128-NEXT: .functype compare_sext_ogt_v4f32 (v128, v128) -> (v128){{$}} 855; SIMD128-NEXT: f32x4.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 856; SIMD128-NEXT: return $pop[[R]]{{$}} 857define <4 x i32> @compare_sext_ogt_v4f32 (<4 x float> %x, <4 x float> %y) { 858 %cmp = fcmp ogt <4 x float> %x, %y 859 %res = sext <4 x i1> %cmp to <4 x i32> 860 ret <4 x i32> %res 861} 862 863; CHECK-LABEL: compare_sext_ogt_nnan_v4f32: 864; NO-SIMD128-NOT: f32x4 865; SIMD128-NEXT: .functype compare_sext_ogt_nnan_v4f32 (v128, v128) -> (v128){{$}} 866; SIMD128-NEXT: f32x4.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 867; SIMD128-NEXT: return $pop[[R]]{{$}} 868define <4 x i32> @compare_sext_ogt_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 869 %cmp = fcmp nnan ogt <4 x float> %x, %y 870 %res = sext <4 x i1> %cmp to <4 x i32> 871 ret <4 x i32> %res 872} 873 874; CHECK-LABEL: compare_oge_v4f32: 875; NO-SIMD128-NOT: f32x4 876; SIMD128-NEXT: .functype compare_oge_v4f32 (v128, v128) -> (v128){{$}} 877; SIMD128-NEXT: f32x4.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 878; SIMD128-NEXT: return $pop[[R]]{{$}} 879define <4 x i1> @compare_oge_v4f32 (<4 x float> %x, <4 x float> %y) { 880 %res = fcmp oge <4 x float> %x, %y 881 ret <4 x i1> %res 882} 883 884; CHECK-LABEL: compare_oge_nnan_v4f32: 885; NO-SIMD128-NOT: f32x4 886; SIMD128-NEXT: .functype compare_oge_nnan_v4f32 (v128, v128) -> (v128){{$}} 887; SIMD128-NEXT: f32x4.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 888; SIMD128-NEXT: return $pop[[R]]{{$}} 889define <4 x i1> @compare_oge_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 890 %res = fcmp nnan oge <4 x float> %x, %y 891 ret <4 x i1> %res 892} 893 894; CHECK-LABEL: compare_sext_oge_v4f32: 895; NO-SIMD128-NOT: f32x4 896; SIMD128-NEXT: .functype compare_sext_oge_v4f32 (v128, v128) -> (v128){{$}} 897; SIMD128-NEXT: f32x4.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 898; SIMD128-NEXT: return $pop[[R]]{{$}} 899define <4 x i32> @compare_sext_oge_v4f32 (<4 x float> %x, <4 x float> %y) { 900 %cmp = fcmp oge <4 x float> %x, %y 901 %res = sext <4 x i1> %cmp to <4 x i32> 902 ret <4 x i32> %res 903} 904 905; CHECK-LABEL: compare_sext_oge_nnan_v4f32: 906; NO-SIMD128-NOT: f32x4 907; SIMD128-NEXT: .functype compare_sext_oge_nnan_v4f32 (v128, v128) -> (v128){{$}} 908; SIMD128-NEXT: f32x4.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 909; SIMD128-NEXT: return $pop[[R]]{{$}} 910define <4 x i32> @compare_sext_oge_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 911 %cmp = fcmp nnan oge <4 x float> %x, %y 912 %res = sext <4 x i1> %cmp to <4 x i32> 913 ret <4 x i32> %res 914} 915 916; CHECK-LABEL: compare_olt_v4f32: 917; NO-SIMD128-NOT: f32x4 918; SIMD128-NEXT: .functype compare_olt_v4f32 (v128, v128) -> (v128){{$}} 919; SIMD128-NEXT: f32x4.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 920; SIMD128-NEXT: return $pop[[R]]{{$}} 921define <4 x i1> @compare_olt_v4f32 (<4 x float> %x, <4 x float> %y) { 922 %res = fcmp olt <4 x float> %x, %y 923 ret <4 x i1> %res 924} 925 926; CHECK-LABEL: compare_olt_nnan_v4f32: 927; NO-SIMD128-NOT: f32x4 928; SIMD128-NEXT: .functype compare_olt_nnan_v4f32 (v128, v128) -> (v128){{$}} 929; SIMD128-NEXT: f32x4.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 930; SIMD128-NEXT: return $pop[[R]]{{$}} 931define <4 x i1> @compare_olt_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 932 %res = fcmp nnan olt <4 x float> %x, %y 933 ret <4 x i1> %res 934} 935 936; CHECK-LABEL: compare_sext_olt_v4f32: 937; NO-SIMD128-NOT: f32x4 938; SIMD128-NEXT: .functype compare_sext_olt_v4f32 (v128, v128) -> (v128){{$}} 939; SIMD128-NEXT: f32x4.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 940; SIMD128-NEXT: return $pop[[R]]{{$}} 941define <4 x i32> @compare_sext_olt_v4f32 (<4 x float> %x, <4 x float> %y) { 942 %cmp = fcmp olt <4 x float> %x, %y 943 %res = sext <4 x i1> %cmp to <4 x i32> 944 ret <4 x i32> %res 945} 946 947; CHECK-LABEL: compare_sext_olt_nnan_v4f32: 948; NO-SIMD128-NOT: f32x4 949; SIMD128-NEXT: .functype compare_sext_olt_nnan_v4f32 (v128, v128) -> (v128){{$}} 950; SIMD128-NEXT: f32x4.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 951; SIMD128-NEXT: return $pop[[R]]{{$}} 952define <4 x i32> @compare_sext_olt_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 953 %cmp = fcmp nnan olt <4 x float> %x, %y 954 %res = sext <4 x i1> %cmp to <4 x i32> 955 ret <4 x i32> %res 956} 957 958; CHECK-LABEL: compare_ole_v4f32: 959; NO-SIMD128-NOT: f32x4 960; SIMD128-NEXT: .functype compare_ole_v4f32 (v128, v128) -> (v128){{$}} 961; SIMD128-NEXT: f32x4.le $push[[R:[0-9]+]]=, $0, $1{{$}} 962; SIMD128-NEXT: return $pop[[R]]{{$}} 963define <4 x i1> @compare_ole_v4f32 (<4 x float> %x, <4 x float> %y) { 964 %res = fcmp ole <4 x float> %x, %y 965 ret <4 x i1> %res 966} 967 968; CHECK-LABEL: compare_ole_nnan_v4f32: 969; NO-SIMD128-NOT: f32x4 970; SIMD128-NEXT: .functype compare_ole_nnan_v4f32 (v128, v128) -> (v128){{$}} 971; SIMD128-NEXT: f32x4.le $push[[R:[0-9]+]]=, $0, $1{{$}} 972; SIMD128-NEXT: return $pop[[R]]{{$}} 973define <4 x i1> @compare_ole_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 974 %res = fcmp nnan ole <4 x float> %x, %y 975 ret <4 x i1> %res 976} 977 978; CHECK-LABEL: compare_sext_ole_v4f32: 979; NO-SIMD128-NOT: f32x4 980; SIMD128-NEXT: .functype compare_sext_ole_v4f32 (v128, v128) -> (v128){{$}} 981; SIMD128-NEXT: f32x4.le $push[[R:[0-9]+]]=, $0, $1{{$}} 982; SIMD128-NEXT: return $pop[[R]]{{$}} 983define <4 x i32> @compare_sext_ole_v4f32 (<4 x float> %x, <4 x float> %y) { 984 %cmp = fcmp ole <4 x float> %x, %y 985 %res = sext <4 x i1> %cmp to <4 x i32> 986 ret <4 x i32> %res 987} 988 989; CHECK-LABEL: compare_sext_ole_nnan_v4f32: 990; NO-SIMD128-NOT: f32x4 991; SIMD128-NEXT: .functype compare_sext_ole_nnan_v4f32 (v128, v128) -> (v128){{$}} 992; SIMD128-NEXT: f32x4.le $push[[R:[0-9]+]]=, $0, $1{{$}} 993; SIMD128-NEXT: return $pop[[R]]{{$}} 994define <4 x i32> @compare_sext_ole_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 995 %cmp = fcmp nnan ole <4 x float> %x, %y 996 %res = sext <4 x i1> %cmp to <4 x i32> 997 ret <4 x i32> %res 998} 999 1000; CHECK-LABEL: compare_one_v4f32: 1001; NO-SIMD128-NOT: f32x4 1002; SIMD128-NEXT: .functype compare_one_v4f32 (v128, v128) -> (v128){{$}} 1003; SIMD128-NEXT: f32x4.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1004; SIMD128-NEXT: f32x4.lt $push[[T1:[0-9]+]]=, $0, $1{{$}} 1005; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1006; SIMD128-NEXT: return $pop[[R]]{{$}} 1007define <4 x i1> @compare_one_v4f32 (<4 x float> %x, <4 x float> %y) { 1008 %res = fcmp one <4 x float> %x, %y 1009 ret <4 x i1> %res 1010} 1011 1012; CHECK-LABEL: compare_one_nnan_v4f32: 1013; NO-SIMD128-NOT: f32x4 1014; SIMD128-NEXT: .functype compare_one_nnan_v4f32 (v128, v128) -> (v128){{$}} 1015; SIMD128-NEXT: f32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1016; SIMD128-NEXT: return $pop[[R]]{{$}} 1017define <4 x i1> @compare_one_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1018 %res = fcmp nnan one <4 x float> %x, %y 1019 ret <4 x i1> %res 1020} 1021 1022; CHECK-LABEL: compare_sext_one_v4f32: 1023; NO-SIMD128-NOT: f32x4 1024; SIMD128-NEXT: .functype compare_sext_one_v4f32 (v128, v128) -> (v128){{$}} 1025; SIMD128-NEXT: f32x4.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1026; SIMD128-NEXT: f32x4.lt $push[[T1:[0-9]+]]=, $0, $1{{$}} 1027; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1028; SIMD128-NEXT: return $pop[[R]]{{$}} 1029define <4 x i32> @compare_sext_one_v4f32 (<4 x float> %x, <4 x float> %y) { 1030 %cmp = fcmp one <4 x float> %x, %y 1031 %res = sext <4 x i1> %cmp to <4 x i32> 1032 ret <4 x i32> %res 1033} 1034 1035; CHECK-LABEL: compare_sext_one_nnan_v4f32: 1036; NO-SIMD128-NOT: f32x4 1037; SIMD128-NEXT: .functype compare_sext_one_nnan_v4f32 (v128, v128) -> (v128){{$}} 1038; SIMD128-NEXT: f32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1039; SIMD128-NEXT: return $pop[[R]]{{$}} 1040define <4 x i32> @compare_sext_one_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1041 %cmp = fcmp nnan one <4 x float> %x, %y 1042 %res = sext <4 x i1> %cmp to <4 x i32> 1043 ret <4 x i32> %res 1044} 1045 1046; CHECK-LABEL: compare_ord_v4f32: 1047; NO-SIMD128-NOT: f32x4 1048; SIMD128-NEXT: .functype compare_ord_v4f32 (v128, v128) -> (v128){{$}} 1049; SIMD128-NEXT: f32x4.eq $push[[T0:[0-9]+]]=, $0, $0{{$}} 1050; SIMD128-NEXT: f32x4.eq $push[[T1:[0-9]+]]=, $1, $1{{$}} 1051; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1052; SIMD128-NEXT: return $pop[[R]]{{$}} 1053define <4 x i1> @compare_ord_v4f32 (<4 x float> %x, <4 x float> %y) { 1054 %res = fcmp ord <4 x float> %x, %y 1055 ret <4 x i1> %res 1056} 1057 1058; CHECK-LABEL: compare_ord_nnan_v4f32: 1059; NO-SIMD128-NOT: f32x4 1060; SIMD128-NEXT: .functype compare_ord_nnan_v4f32 (v128, v128) -> (v128){{$}} 1061; SIMD128-NEXT: f32x4.eq $push[[T0:[0-9]+]]=, $0, $0{{$}} 1062; SIMD128-NEXT: f32x4.eq $push[[T1:[0-9]+]]=, $1, $1{{$}} 1063; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1064; SIMD128-NEXT: return $pop[[R]]{{$}} 1065define <4 x i1> @compare_ord_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1066 %res = fcmp nnan ord <4 x float> %x, %y 1067 ret <4 x i1> %res 1068} 1069 1070; CHECK-LABEL: compare_sext_ord_v4f32: 1071; NO-SIMD128-NOT: f32x4 1072; SIMD128-NEXT: .functype compare_sext_ord_v4f32 (v128, v128) -> (v128){{$}} 1073; SIMD128-NEXT: f32x4.eq $push[[T0:[0-9]+]]=, $0, $0{{$}} 1074; SIMD128-NEXT: f32x4.eq $push[[T1:[0-9]+]]=, $1, $1{{$}} 1075; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1076; SIMD128-NEXT: return $pop[[R]]{{$}} 1077define <4 x i32> @compare_sext_ord_v4f32 (<4 x float> %x, <4 x float> %y) { 1078 %cmp = fcmp ord <4 x float> %x, %y 1079 %res = sext <4 x i1> %cmp to <4 x i32> 1080 ret <4 x i32> %res 1081} 1082 1083; CHECK-LABEL: compare_sext_ord_nnan_v4f32: 1084; NO-SIMD128-NOT: f32x4 1085; SIMD128-NEXT: .functype compare_sext_ord_nnan_v4f32 (v128, v128) -> (v128){{$}} 1086; SIMD128-NEXT: f32x4.eq $push[[T0:[0-9]+]]=, $0, $0{{$}} 1087; SIMD128-NEXT: f32x4.eq $push[[T1:[0-9]+]]=, $1, $1{{$}} 1088; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1089; SIMD128-NEXT: return $pop[[R]]{{$}} 1090define <4 x i32> @compare_sext_ord_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1091 %cmp = fcmp nnan ord <4 x float> %x, %y 1092 %res = sext <4 x i1> %cmp to <4 x i32> 1093 ret <4 x i32> %res 1094} 1095 1096; CHECK-LABEL: compare_ueq_v4f32: 1097; NO-SIMD128-NOT: f32x4 1098; SIMD128-NEXT: .functype compare_ueq_v4f32 (v128, v128) -> (v128){{$}} 1099; SIMD128-NEXT: f32x4.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1100; SIMD128-NEXT: f32x4.lt $push[[T1:[0-9]+]]=, $0, $1{{$}} 1101; SIMD128-NEXT: v128.or $push[[T2:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1102; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T2]]{{$}} 1103; SIMD128-NEXT: return $pop[[R]]{{$}} 1104define <4 x i1> @compare_ueq_v4f32 (<4 x float> %x, <4 x float> %y) { 1105 %res = fcmp ueq <4 x float> %x, %y 1106 ret <4 x i1> %res 1107} 1108 1109; CHECK-LABEL: compare_ueq_nnan_v4f32: 1110; NO-SIMD128-NOT: f32x4 1111; SIMD128-NEXT: .functype compare_ueq_nnan_v4f32 (v128, v128) -> (v128){{$}} 1112; SIMD128-NEXT: f32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 1113; SIMD128-NEXT: return $pop[[R]]{{$}} 1114define <4 x i1> @compare_ueq_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1115 %res = fcmp nnan ueq <4 x float> %x, %y 1116 ret <4 x i1> %res 1117} 1118 1119; CHECK-LABEL: compare_sext_ueq_v4f32: 1120; NO-SIMD128-NOT: f32x4 1121; SIMD128-NEXT: .functype compare_sext_ueq_v4f32 (v128, v128) -> (v128){{$}} 1122; SIMD128-NEXT: f32x4.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1123; SIMD128-NEXT: f32x4.lt $push[[T1:[0-9]+]]=, $0, $1{{$}} 1124; SIMD128-NEXT: v128.or $push[[T2:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1125; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T2]]{{$}} 1126; SIMD128-NEXT: return $pop[[R]] 1127define <4 x i32> @compare_sext_ueq_v4f32 (<4 x float> %x, <4 x float> %y) { 1128 %cmp = fcmp ueq <4 x float> %x, %y 1129 %res = sext <4 x i1> %cmp to <4 x i32> 1130 ret <4 x i32> %res 1131} 1132 1133; CHECK-LABEL: compare_sext_ueq_nnan_v4f32: 1134; NO-SIMD128-NOT: f32x4 1135; SIMD128-NEXT: .functype compare_sext_ueq_nnan_v4f32 (v128, v128) -> (v128){{$}} 1136; SIMD128-NEXT: f32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 1137; SIMD128-NEXT: return $pop[[R]] 1138define <4 x i32> @compare_sext_ueq_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1139 %cmp = fcmp nnan ueq <4 x float> %x, %y 1140 %res = sext <4 x i1> %cmp to <4 x i32> 1141 ret <4 x i32> %res 1142} 1143 1144; CHECK-LABEL: compare_ugt_v4f32: 1145; NO-SIMD128-NOT: f32x4 1146; SIMD128-NEXT: .functype compare_ugt_v4f32 (v128, v128) -> (v128){{$}} 1147; SIMD128-NEXT: f32x4.le $push[[T0:[0-9]+]]=, $0, $1{{$}} 1148; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1149; SIMD128-NEXT: return $pop[[R]]{{$}} 1150define <4 x i1> @compare_ugt_v4f32 (<4 x float> %x, <4 x float> %y) { 1151 %res = fcmp ugt <4 x float> %x, %y 1152 ret <4 x i1> %res 1153} 1154 1155; CHECK-LABEL: compare_ugt_nnan_v4f32: 1156; NO-SIMD128-NOT: f32x4 1157; SIMD128-NEXT: .functype compare_ugt_nnan_v4f32 (v128, v128) -> (v128){{$}} 1158; SIMD128-NEXT: f32x4.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 1159; SIMD128-NEXT: return $pop[[R]]{{$}} 1160define <4 x i1> @compare_ugt_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1161 %res = fcmp nnan ugt <4 x float> %x, %y 1162 ret <4 x i1> %res 1163} 1164 1165; CHECK-LABEL: compare_sext_ugt_v4f32: 1166; NO-SIMD128-NOT: f32x4 1167; SIMD128-NEXT: .functype compare_sext_ugt_v4f32 (v128, v128) -> (v128){{$}} 1168; SIMD128-NEXT: f32x4.le $push[[T0:[0-9]+]]=, $0, $1{{$}} 1169; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1170; SIMD128-NEXT: return $pop[[R]]{{$}} 1171define <4 x i32> @compare_sext_ugt_v4f32 (<4 x float> %x, <4 x float> %y) { 1172 %cmp = fcmp ugt <4 x float> %x, %y 1173 %res = sext <4 x i1> %cmp to <4 x i32> 1174 ret <4 x i32> %res 1175} 1176 1177; CHECK-LABEL: compare_sext_ugt_nnan_v4f32: 1178; NO-SIMD128-NOT: f32x4 1179; SIMD128-NEXT: .functype compare_sext_ugt_nnan_v4f32 (v128, v128) -> (v128){{$}} 1180; SIMD128-NEXT: f32x4.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 1181; SIMD128-NEXT: return $pop[[R]]{{$}} 1182define <4 x i32> @compare_sext_ugt_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1183 %cmp = fcmp nnan ugt <4 x float> %x, %y 1184 %res = sext <4 x i1> %cmp to <4 x i32> 1185 ret <4 x i32> %res 1186} 1187 1188; CHECK-LABEL: compare_uge_v4f32: 1189; NO-SIMD128-NOT: f32x4 1190; SIMD128-NEXT: .functype compare_uge_v4f32 (v128, v128) -> (v128){{$}} 1191; SIMD128-NEXT: f32x4.lt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1192; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1193; SIMD128-NEXT: return $pop[[R]]{{$}} 1194define <4 x i1> @compare_uge_v4f32 (<4 x float> %x, <4 x float> %y) { 1195 %res = fcmp uge <4 x float> %x, %y 1196 ret <4 x i1> %res 1197} 1198 1199; CHECK-LABEL: compare_uge_nnan_v4f32: 1200; NO-SIMD128-NOT: f32x4 1201; SIMD128-NEXT: .functype compare_uge_nnan_v4f32 (v128, v128) -> (v128){{$}} 1202; SIMD128-NEXT: f32x4.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 1203; SIMD128-NEXT: return $pop[[R]]{{$}} 1204define <4 x i1> @compare_uge_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1205 %res = fcmp nnan uge <4 x float> %x, %y 1206 ret <4 x i1> %res 1207} 1208 1209; CHECK-LABEL: compare_sext_uge_v4f32: 1210; NO-SIMD128-NOT: f32x4 1211; SIMD128-NEXT: .functype compare_sext_uge_v4f32 (v128, v128) -> (v128){{$}} 1212; SIMD128-NEXT: f32x4.lt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1213; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1214; SIMD128-NEXT: return $pop[[R]]{{$}} 1215define <4 x i32> @compare_sext_uge_v4f32 (<4 x float> %x, <4 x float> %y) { 1216 %cmp = fcmp uge <4 x float> %x, %y 1217 %res = sext <4 x i1> %cmp to <4 x i32> 1218 ret <4 x i32> %res 1219} 1220 1221; CHECK-LABEL: compare_sext_uge_nnan_v4f32: 1222; NO-SIMD128-NOT: f32x4 1223; SIMD128-NEXT: .functype compare_sext_uge_nnan_v4f32 (v128, v128) -> (v128){{$}} 1224; SIMD128-NEXT: f32x4.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 1225; SIMD128-NEXT: return $pop[[R]]{{$}} 1226define <4 x i32> @compare_sext_uge_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1227 %cmp = fcmp nnan uge <4 x float> %x, %y 1228 %res = sext <4 x i1> %cmp to <4 x i32> 1229 ret <4 x i32> %res 1230} 1231 1232; CHECK-LABEL: compare_ult_v4f32: 1233; NO-SIMD128-NOT: f32x4 1234; SIMD128-NEXT: .functype compare_ult_v4f32 (v128, v128) -> (v128){{$}} 1235; SIMD128-NEXT: f32x4.ge $push[[T0:[0-9]+]]=, $0, $1{{$}} 1236; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1237; SIMD128-NEXT: return $pop[[R]]{{$}} 1238define <4 x i1> @compare_ult_v4f32 (<4 x float> %x, <4 x float> %y) { 1239 %res = fcmp ult <4 x float> %x, %y 1240 ret <4 x i1> %res 1241} 1242 1243; CHECK-LABEL: compare_ult_nnan_v4f32: 1244; NO-SIMD128-NOT: f32x4 1245; SIMD128-NEXT: .functype compare_ult_nnan_v4f32 (v128, v128) -> (v128){{$}} 1246; SIMD128-NEXT: f32x4.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 1247; SIMD128-NEXT: return $pop[[R]]{{$}} 1248define <4 x i1> @compare_ult_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1249 %res = fcmp nnan ult <4 x float> %x, %y 1250 ret <4 x i1> %res 1251} 1252 1253; CHECK-LABEL: compare_sext_ult_v4f32: 1254; NO-SIMD128-NOT: f32x4 1255; SIMD128-NEXT: .functype compare_sext_ult_v4f32 (v128, v128) -> (v128){{$}} 1256; SIMD128-NEXT: f32x4.ge $push[[T0:[0-9]+]]=, $0, $1{{$}} 1257; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1258; SIMD128-NEXT: return $pop[[R]]{{$}} 1259define <4 x i32> @compare_sext_ult_v4f32 (<4 x float> %x, <4 x float> %y) { 1260 %cmp = fcmp ult <4 x float> %x, %y 1261 %res = sext <4 x i1> %cmp to <4 x i32> 1262 ret <4 x i32> %res 1263} 1264 1265; CHECK-LABEL: compare_sext_ult_nnan_v4f32: 1266; NO-SIMD128-NOT: f32x4 1267; SIMD128-NEXT: .functype compare_sext_ult_nnan_v4f32 (v128, v128) -> (v128){{$}} 1268; SIMD128-NEXT: f32x4.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 1269; SIMD128-NEXT: return $pop[[R]]{{$}} 1270define <4 x i32> @compare_sext_ult_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1271 %cmp = fcmp nnan ult <4 x float> %x, %y 1272 %res = sext <4 x i1> %cmp to <4 x i32> 1273 ret <4 x i32> %res 1274} 1275 1276; CHECK-LABEL: compare_ule_v4f32: 1277; NO-SIMD128-NOT: f32x4 1278; SIMD128-NEXT: .functype compare_ule_v4f32 (v128, v128) -> (v128){{$}} 1279; SIMD128-NEXT: f32x4.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1280; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1281; SIMD128-NEXT: return $pop[[R]]{{$}} 1282define <4 x i1> @compare_ule_v4f32 (<4 x float> %x, <4 x float> %y) { 1283 %res = fcmp ule <4 x float> %x, %y 1284 ret <4 x i1> %res 1285} 1286 1287; CHECK-LABEL: compare_ule_nnan_v4f32: 1288; NO-SIMD128-NOT: f32x4 1289; SIMD128-NEXT: .functype compare_ule_nnan_v4f32 (v128, v128) -> (v128){{$}} 1290; SIMD128-NEXT: f32x4.le $push[[R:[0-9]+]]=, $0, $1{{$}} 1291; SIMD128-NEXT: return $pop[[R]]{{$}} 1292define <4 x i1> @compare_ule_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1293 %res = fcmp nnan ule <4 x float> %x, %y 1294 ret <4 x i1> %res 1295} 1296 1297; CHECK-LABEL: compare_sext_ule_v4f32: 1298; NO-SIMD128-NOT: f32x4 1299; SIMD128-NEXT: .functype compare_sext_ule_v4f32 (v128, v128) -> (v128){{$}} 1300; SIMD128-NEXT: f32x4.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1301; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1302; SIMD128-NEXT: return $pop[[R]]{{$}} 1303define <4 x i32> @compare_sext_ule_v4f32 (<4 x float> %x, <4 x float> %y) { 1304 %cmp = fcmp ule <4 x float> %x, %y 1305 %res = sext <4 x i1> %cmp to <4 x i32> 1306 ret <4 x i32> %res 1307} 1308 1309; CHECK-LABEL: compare_sext_ule_nnan_v4f32: 1310; NO-SIMD128-NOT: f32x4 1311; SIMD128-NEXT: .functype compare_sext_ule_nnan_v4f32 (v128, v128) -> (v128){{$}} 1312; SIMD128-NEXT: f32x4.le $push[[R:[0-9]+]]=, $0, $1{{$}} 1313; SIMD128-NEXT: return $pop[[R]]{{$}} 1314define <4 x i32> @compare_sext_ule_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1315 %cmp = fcmp nnan ule <4 x float> %x, %y 1316 %res = sext <4 x i1> %cmp to <4 x i32> 1317 ret <4 x i32> %res 1318} 1319 1320; CHECK-LABEL: compare_une_v4f32: 1321; NO-SIMD128-NOT: f32x4 1322; SIMD128-NEXT: .functype compare_une_v4f32 (v128, v128) -> (v128){{$}} 1323; SIMD128-NEXT: f32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}}{{$}} 1324; SIMD128-NEXT: return $pop[[R]]{{$}} 1325define <4 x i1> @compare_une_v4f32 (<4 x float> %x, <4 x float> %y) { 1326 %res = fcmp une <4 x float> %x, %y 1327 ret <4 x i1> %res 1328} 1329 1330; CHECK-LABEL: compare_une_nnan_v4f32: 1331; NO-SIMD128-NOT: f32x4 1332; SIMD128-NEXT: .functype compare_une_nnan_v4f32 (v128, v128) -> (v128){{$}} 1333; SIMD128-NEXT: f32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}}{{$}} 1334; SIMD128-NEXT: return $pop[[R]]{{$}} 1335define <4 x i1> @compare_une_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1336 %res = fcmp nnan une <4 x float> %x, %y 1337 ret <4 x i1> %res 1338} 1339 1340; CHECK-LABEL: compare_sext_une_v4f32: 1341; NO-SIMD128-NOT: f32x4 1342; SIMD128-NEXT: .functype compare_sext_une_v4f32 (v128, v128) -> (v128){{$}} 1343; SIMD128-NEXT: f32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1344; SIMD128-NEXT: return $pop[[R]]{{$}} 1345define <4 x i32> @compare_sext_une_v4f32 (<4 x float> %x, <4 x float> %y) { 1346 %cmp = fcmp une <4 x float> %x, %y 1347 %res = sext <4 x i1> %cmp to <4 x i32> 1348 ret <4 x i32> %res 1349} 1350 1351; CHECK-LABEL: compare_sext_une_nnan_v4f32: 1352; NO-SIMD128-NOT: f32x4 1353; SIMD128-NEXT: .functype compare_sext_une_nnan_v4f32 (v128, v128) -> (v128){{$}} 1354; SIMD128-NEXT: f32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1355; SIMD128-NEXT: return $pop[[R]]{{$}} 1356define <4 x i32> @compare_sext_une_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1357 %cmp = fcmp nnan une <4 x float> %x, %y 1358 %res = sext <4 x i1> %cmp to <4 x i32> 1359 ret <4 x i32> %res 1360} 1361 1362; CHECK-LABEL: compare_uno_v4f32: 1363; NO-SIMD128-NOT: f32x4 1364; SIMD128-NEXT: .functype compare_uno_v4f32 (v128, v128) -> (v128){{$}} 1365; SIMD128-NEXT: f32x4.ne $push[[T0:[0-9]+]]=, $0, $0{{$}} 1366; SIMD128-NEXT: f32x4.ne $push[[T1:[0-9]+]]=, $1, $1{{$}} 1367; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1368; SIMD128-NEXT: return $pop[[R]]{{$}} 1369define <4 x i1> @compare_uno_v4f32 (<4 x float> %x, <4 x float> %y) { 1370 %res = fcmp uno <4 x float> %x, %y 1371 ret <4 x i1> %res 1372} 1373 1374; CHECK-LABEL: compare_uno_nnan_v4f32: 1375; NO-SIMD128-NOT: f32x4 1376; SIMD128-NEXT: .functype compare_uno_nnan_v4f32 (v128, v128) -> (v128){{$}} 1377; SIMD128-NEXT: f32x4.ne $push[[T0:[0-9]+]]=, $0, $0{{$}} 1378; SIMD128-NEXT: f32x4.ne $push[[T1:[0-9]+]]=, $1, $1{{$}} 1379; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1380; SIMD128-NEXT: return $pop[[R]]{{$}} 1381define <4 x i1> @compare_uno_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1382 %res = fcmp nnan uno <4 x float> %x, %y 1383 ret <4 x i1> %res 1384} 1385 1386; CHECK-LABEL: compare_sext_uno_v4f32: 1387; NO-SIMD128-NOT: f32x4 1388; SIMD128-NEXT: .functype compare_sext_uno_v4f32 (v128, v128) -> (v128){{$}} 1389; SIMD128-NEXT: f32x4.ne $push[[T0:[0-9]+]]=, $0, $0{{$}} 1390; SIMD128-NEXT: f32x4.ne $push[[T1:[0-9]+]]=, $1, $1{{$}} 1391; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1392; SIMD128-NEXT: return $pop[[R]]{{$}} 1393define <4 x i32> @compare_sext_uno_v4f32 (<4 x float> %x, <4 x float> %y) { 1394 %cmp = fcmp uno <4 x float> %x, %y 1395 %res = sext <4 x i1> %cmp to <4 x i32> 1396 ret <4 x i32> %res 1397} 1398 1399; CHECK-LABEL: compare_sext_uno_nnan_v4f32: 1400; NO-SIMD128-NOT: f32x4 1401; SIMD128-NEXT: .functype compare_sext_uno_nnan_v4f32 (v128, v128) -> (v128){{$}} 1402; SIMD128-NEXT: f32x4.ne $push[[T0:[0-9]+]]=, $0, $0{{$}} 1403; SIMD128-NEXT: f32x4.ne $push[[T1:[0-9]+]]=, $1, $1{{$}} 1404; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1405; SIMD128-NEXT: return $pop[[R]]{{$}} 1406define <4 x i32> @compare_sext_uno_nnan_v4f32 (<4 x float> %x, <4 x float> %y) { 1407 %cmp = fcmp nnan uno <4 x float> %x, %y 1408 %res = sext <4 x i1> %cmp to <4 x i32> 1409 ret <4 x i32> %res 1410} 1411 1412; CHECK-LABEL: compare_oeq_v2f64: 1413; NO-SIMD128-NOT: f64x2 1414; SIMD128-NEXT: .functype compare_oeq_v2f64 (v128, v128) -> (v128){{$}} 1415; SIMD128-NEXT: f64x2.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 1416; SIMD128-NEXT: return $pop[[R]]{{$}} 1417define <2 x i1> @compare_oeq_v2f64 (<2 x double> %x, <2 x double> %y) { 1418 %res = fcmp oeq <2 x double> %x, %y 1419 ret <2 x i1> %res 1420} 1421 1422; CHECK-LABEL: compare_oeq_nnan_v2f64: 1423; NO-SIMD128-NOT: f64x2 1424; SIMD128-NEXT: .functype compare_oeq_nnan_v2f64 (v128, v128) -> (v128){{$}} 1425; SIMD128-NEXT: f64x2.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 1426; SIMD128-NEXT: return $pop[[R]]{{$}} 1427define <2 x i1> @compare_oeq_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1428 %res = fcmp nnan oeq <2 x double> %x, %y 1429 ret <2 x i1> %res 1430} 1431 1432; CHECK-LABEL: compare_sext_oeq_v2f64: 1433; NO-SIMD128-NOT: f64x2 1434; SIMD128-NEXT: .functype compare_sext_oeq_v2f64 (v128, v128) -> (v128){{$}} 1435; SIMD128-NEXT: f64x2.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 1436; SIMD128-NEXT: return $pop[[R]]{{$}} 1437define <2 x i64> @compare_sext_oeq_v2f64 (<2 x double> %x, <2 x double> %y) { 1438 %cmp = fcmp oeq <2 x double> %x, %y 1439 %res = sext <2 x i1> %cmp to <2 x i64> 1440 ret <2 x i64> %res 1441} 1442 1443; CHECK-LABEL: compare_sext_oeq_nnan_v2f64: 1444; NO-SIMD128-NOT: f64x2 1445; SIMD128-NEXT: .functype compare_sext_oeq_nnan_v2f64 (v128, v128) -> (v128){{$}} 1446; SIMD128-NEXT: f64x2.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 1447; SIMD128-NEXT: return $pop[[R]]{{$}} 1448define <2 x i64> @compare_sext_oeq_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1449 %cmp = fcmp nnan oeq <2 x double> %x, %y 1450 %res = sext <2 x i1> %cmp to <2 x i64> 1451 ret <2 x i64> %res 1452} 1453 1454; CHECK-LABEL: compare_ogt_v2f64: 1455; NO-SIMD128-NOT: f64x2 1456; SIMD128-NEXT: .functype compare_ogt_v2f64 (v128, v128) -> (v128){{$}} 1457; SIMD128-NEXT: f64x2.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 1458; SIMD128-NEXT: return $pop[[R]]{{$}} 1459define <2 x i1> @compare_ogt_v2f64 (<2 x double> %x, <2 x double> %y) { 1460 %res = fcmp ogt <2 x double> %x, %y 1461 ret <2 x i1> %res 1462} 1463 1464; CHECK-LABEL: compare_ogt_nnan_v2f64: 1465; NO-SIMD128-NOT: f64x2 1466; SIMD128-NEXT: .functype compare_ogt_nnan_v2f64 (v128, v128) -> (v128){{$}} 1467; SIMD128-NEXT: f64x2.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 1468; SIMD128-NEXT: return $pop[[R]]{{$}} 1469define <2 x i1> @compare_ogt_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1470 %res = fcmp nnan ogt <2 x double> %x, %y 1471 ret <2 x i1> %res 1472} 1473 1474; CHECK-LABEL: compare_sext_ogt_v2f64: 1475; NO-SIMD128-NOT: f64x2 1476; SIMD128-NEXT: .functype compare_sext_ogt_v2f64 (v128, v128) -> (v128){{$}} 1477; SIMD128-NEXT: f64x2.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 1478; SIMD128-NEXT: return $pop[[R]]{{$}} 1479define <2 x i64> @compare_sext_ogt_v2f64 (<2 x double> %x, <2 x double> %y) { 1480 %cmp = fcmp ogt <2 x double> %x, %y 1481 %res = sext <2 x i1> %cmp to <2 x i64> 1482 ret <2 x i64> %res 1483} 1484 1485; CHECK-LABEL: compare_sext_ogt_nnan_v2f64: 1486; NO-SIMD128-NOT: f64x2 1487; SIMD128-NEXT: .functype compare_sext_ogt_nnan_v2f64 (v128, v128) -> (v128){{$}} 1488; SIMD128-NEXT: f64x2.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 1489; SIMD128-NEXT: return $pop[[R]]{{$}} 1490define <2 x i64> @compare_sext_ogt_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1491 %cmp = fcmp nnan ogt <2 x double> %x, %y 1492 %res = sext <2 x i1> %cmp to <2 x i64> 1493 ret <2 x i64> %res 1494} 1495 1496; CHECK-LABEL: compare_oge_v2f64: 1497; NO-SIMD128-NOT: f64x2 1498; SIMD128-NEXT: .functype compare_oge_v2f64 (v128, v128) -> (v128){{$}} 1499; SIMD128-NEXT: f64x2.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 1500; SIMD128-NEXT: return $pop[[R]]{{$}} 1501define <2 x i1> @compare_oge_v2f64 (<2 x double> %x, <2 x double> %y) { 1502 %res = fcmp oge <2 x double> %x, %y 1503 ret <2 x i1> %res 1504} 1505 1506; CHECK-LABEL: compare_oge_nnan_v2f64: 1507; NO-SIMD128-NOT: f64x2 1508; SIMD128-NEXT: .functype compare_oge_nnan_v2f64 (v128, v128) -> (v128){{$}} 1509; SIMD128-NEXT: f64x2.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 1510; SIMD128-NEXT: return $pop[[R]]{{$}} 1511define <2 x i1> @compare_oge_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1512 %res = fcmp nnan oge <2 x double> %x, %y 1513 ret <2 x i1> %res 1514} 1515 1516; CHECK-LABEL: compare_sext_oge_v2f64: 1517; NO-SIMD128-NOT: f64x2 1518; SIMD128-NEXT: .functype compare_sext_oge_v2f64 (v128, v128) -> (v128){{$}} 1519; SIMD128-NEXT: f64x2.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 1520; SIMD128-NEXT: return $pop[[R]]{{$}} 1521define <2 x i64> @compare_sext_oge_v2f64 (<2 x double> %x, <2 x double> %y) { 1522 %cmp = fcmp oge <2 x double> %x, %y 1523 %res = sext <2 x i1> %cmp to <2 x i64> 1524 ret <2 x i64> %res 1525} 1526 1527; CHECK-LABEL: compare_sext_oge_nnan_v2f64: 1528; NO-SIMD128-NOT: f64x2 1529; SIMD128-NEXT: .functype compare_sext_oge_nnan_v2f64 (v128, v128) -> (v128){{$}} 1530; SIMD128-NEXT: f64x2.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 1531; SIMD128-NEXT: return $pop[[R]]{{$}} 1532define <2 x i64> @compare_sext_oge_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1533 %cmp = fcmp nnan oge <2 x double> %x, %y 1534 %res = sext <2 x i1> %cmp to <2 x i64> 1535 ret <2 x i64> %res 1536} 1537 1538; CHECK-LABEL: compare_olt_v2f64: 1539; NO-SIMD128-NOT: f64x2 1540; SIMD128-NEXT: .functype compare_olt_v2f64 (v128, v128) -> (v128){{$}} 1541; SIMD128-NEXT: f64x2.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 1542; SIMD128-NEXT: return $pop[[R]]{{$}} 1543define <2 x i1> @compare_olt_v2f64 (<2 x double> %x, <2 x double> %y) { 1544 %res = fcmp olt <2 x double> %x, %y 1545 ret <2 x i1> %res 1546} 1547 1548; CHECK-LABEL: compare_olt_nnan_v2f64: 1549; NO-SIMD128-NOT: f64x2 1550; SIMD128-NEXT: .functype compare_olt_nnan_v2f64 (v128, v128) -> (v128){{$}} 1551; SIMD128-NEXT: f64x2.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 1552; SIMD128-NEXT: return $pop[[R]]{{$}} 1553define <2 x i1> @compare_olt_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1554 %res = fcmp nnan olt <2 x double> %x, %y 1555 ret <2 x i1> %res 1556} 1557 1558; CHECK-LABEL: compare_sext_olt_v2f64: 1559; NO-SIMD128-NOT: f64x2 1560; SIMD128-NEXT: .functype compare_sext_olt_v2f64 (v128, v128) -> (v128){{$}} 1561; SIMD128-NEXT: f64x2.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 1562; SIMD128-NEXT: return $pop[[R]]{{$}} 1563define <2 x i64> @compare_sext_olt_v2f64 (<2 x double> %x, <2 x double> %y) { 1564 %cmp = fcmp olt <2 x double> %x, %y 1565 %res = sext <2 x i1> %cmp to <2 x i64> 1566 ret <2 x i64> %res 1567} 1568 1569; CHECK-LABEL: compare_sext_olt_nnan_v2f64: 1570; NO-SIMD128-NOT: f64x2 1571; SIMD128-NEXT: .functype compare_sext_olt_nnan_v2f64 (v128, v128) -> (v128){{$}} 1572; SIMD128-NEXT: f64x2.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 1573; SIMD128-NEXT: return $pop[[R]]{{$}} 1574define <2 x i64> @compare_sext_olt_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1575 %cmp = fcmp nnan olt <2 x double> %x, %y 1576 %res = sext <2 x i1> %cmp to <2 x i64> 1577 ret <2 x i64> %res 1578} 1579 1580; CHECK-LABEL: compare_ole_v2f64: 1581; NO-SIMD128-NOT: f64x2 1582; SIMD128-NEXT: .functype compare_ole_v2f64 (v128, v128) -> (v128){{$}} 1583; SIMD128-NEXT: f64x2.le $push[[R:[0-9]+]]=, $0, $1{{$}} 1584; SIMD128-NEXT: return $pop[[R]]{{$}} 1585define <2 x i1> @compare_ole_v2f64 (<2 x double> %x, <2 x double> %y) { 1586 %res = fcmp ole <2 x double> %x, %y 1587 ret <2 x i1> %res 1588} 1589 1590; CHECK-LABEL: compare_ole_nnan_v2f64: 1591; NO-SIMD128-NOT: f64x2 1592; SIMD128-NEXT: .functype compare_ole_nnan_v2f64 (v128, v128) -> (v128){{$}} 1593; SIMD128-NEXT: f64x2.le $push[[R:[0-9]+]]=, $0, $1{{$}} 1594; SIMD128-NEXT: return $pop[[R]]{{$}} 1595define <2 x i1> @compare_ole_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1596 %res = fcmp nnan ole <2 x double> %x, %y 1597 ret <2 x i1> %res 1598} 1599 1600; CHECK-LABEL: compare_sext_ole_v2f64: 1601; NO-SIMD128-NOT: f64x2 1602; SIMD128-NEXT: .functype compare_sext_ole_v2f64 (v128, v128) -> (v128){{$}} 1603; SIMD128-NEXT: f64x2.le $push[[R:[0-9]+]]=, $0, $1{{$}} 1604; SIMD128-NEXT: return $pop[[R]]{{$}} 1605define <2 x i64> @compare_sext_ole_v2f64 (<2 x double> %x, <2 x double> %y) { 1606 %cmp = fcmp ole <2 x double> %x, %y 1607 %res = sext <2 x i1> %cmp to <2 x i64> 1608 ret <2 x i64> %res 1609} 1610 1611; CHECK-LABEL: compare_sext_ole_nnan_v2f64: 1612; NO-SIMD128-NOT: f64x2 1613; SIMD128-NEXT: .functype compare_sext_ole_nnan_v2f64 (v128, v128) -> (v128){{$}} 1614; SIMD128-NEXT: f64x2.le $push[[R:[0-9]+]]=, $0, $1{{$}} 1615; SIMD128-NEXT: return $pop[[R]]{{$}} 1616define <2 x i64> @compare_sext_ole_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1617 %cmp = fcmp nnan ole <2 x double> %x, %y 1618 %res = sext <2 x i1> %cmp to <2 x i64> 1619 ret <2 x i64> %res 1620} 1621 1622; CHECK-LABEL: compare_one_v2f64: 1623; NO-SIMD128-NOT: f64x2 1624; SIMD128-NEXT: .functype compare_one_v2f64 (v128, v128) -> (v128){{$}} 1625; SIMD128-NEXT: f64x2.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1626; SIMD128-NEXT: f64x2.lt $push[[T1:[0-9]+]]=, $0, $1{{$}} 1627; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1628; SIMD128-NEXT: return $pop[[R]]{{$}} 1629define <2 x i1> @compare_one_v2f64 (<2 x double> %x, <2 x double> %y) { 1630 %res = fcmp one <2 x double> %x, %y 1631 ret <2 x i1> %res 1632} 1633 1634; CHECK-LABEL: compare_one_nnan_v2f64: 1635; NO-SIMD128-NOT: f64x2 1636; SIMD128-NEXT: .functype compare_one_nnan_v2f64 (v128, v128) -> (v128){{$}} 1637; SIMD128-NEXT: f64x2.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1638; SIMD128-NEXT: return $pop[[R]]{{$}} 1639define <2 x i1> @compare_one_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1640 %res = fcmp nnan one <2 x double> %x, %y 1641 ret <2 x i1> %res 1642} 1643 1644; CHECK-LABEL: compare_sext_one_v2f64: 1645; NO-SIMD128-NOT: f64x2 1646; SIMD128-NEXT: .functype compare_sext_one_v2f64 (v128, v128) -> (v128){{$}} 1647; SIMD128-NEXT: f64x2.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1648; SIMD128-NEXT: f64x2.lt $push[[T1:[0-9]+]]=, $0, $1{{$}} 1649; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1650; SIMD128-NEXT: return $pop[[R]]{{$}} 1651define <2 x i64> @compare_sext_one_v2f64 (<2 x double> %x, <2 x double> %y) { 1652 %cmp = fcmp one <2 x double> %x, %y 1653 %res = sext <2 x i1> %cmp to <2 x i64> 1654 ret <2 x i64> %res 1655} 1656 1657; CHECK-LABEL: compare_sext_one_nnan_v2f64: 1658; NO-SIMD128-NOT: f64x2 1659; SIMD128-NEXT: .functype compare_sext_one_nnan_v2f64 (v128, v128) -> (v128){{$}} 1660; SIMD128-NEXT: f64x2.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1661; SIMD128-NEXT: return $pop[[R]]{{$}} 1662define <2 x i64> @compare_sext_one_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1663 %cmp = fcmp nnan one <2 x double> %x, %y 1664 %res = sext <2 x i1> %cmp to <2 x i64> 1665 ret <2 x i64> %res 1666} 1667 1668; CHECK-LABEL: compare_ord_v2f64: 1669; NO-SIMD128-NOT: f64x2 1670; SIMD128-NEXT: .functype compare_ord_v2f64 (v128, v128) -> (v128){{$}} 1671; SIMD128-NEXT: f64x2.eq $push[[T0:[0-9]+]]=, $0, $0{{$}} 1672; SIMD128-NEXT: f64x2.eq $push[[T1:[0-9]+]]=, $1, $1{{$}} 1673; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1674; SIMD128-NEXT: return $pop[[R]]{{$}} 1675define <2 x i1> @compare_ord_v2f64 (<2 x double> %x, <2 x double> %y) { 1676 %res = fcmp ord <2 x double> %x, %y 1677 ret <2 x i1> %res 1678} 1679 1680; CHECK-LABEL: compare_ord_nnan_v2f64: 1681; NO-SIMD128-NOT: f64x2 1682; SIMD128-NEXT: .functype compare_ord_nnan_v2f64 (v128, v128) -> (v128){{$}} 1683; SIMD128-NEXT: f64x2.eq $push[[T0:[0-9]+]]=, $0, $0{{$}} 1684; SIMD128-NEXT: f64x2.eq $push[[T1:[0-9]+]]=, $1, $1{{$}} 1685; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1686; SIMD128-NEXT: return $pop[[R]]{{$}} 1687define <2 x i1> @compare_ord_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1688 %res = fcmp nnan ord <2 x double> %x, %y 1689 ret <2 x i1> %res 1690} 1691 1692; CHECK-LABEL: compare_sext_ord_v2f64: 1693; NO-SIMD128-NOT: f64x2 1694; SIMD128-NEXT: .functype compare_sext_ord_v2f64 (v128, v128) -> (v128){{$}} 1695; SIMD128-NEXT: f64x2.eq $push[[T0:[0-9]+]]=, $0, $0{{$}} 1696; SIMD128-NEXT: f64x2.eq $push[[T1:[0-9]+]]=, $1, $1{{$}} 1697; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1698; SIMD128-NEXT: return $pop[[R]]{{$}} 1699define <2 x i64> @compare_sext_ord_v2f64 (<2 x double> %x, <2 x double> %y) { 1700 %cmp = fcmp ord <2 x double> %x, %y 1701 %res = sext <2 x i1> %cmp to <2 x i64> 1702 ret <2 x i64> %res 1703} 1704 1705; CHECK-LABEL: compare_sext_ord_nnan_v2f64: 1706; NO-SIMD128-NOT: f64x2 1707; SIMD128-NEXT: .functype compare_sext_ord_nnan_v2f64 (v128, v128) -> (v128){{$}} 1708; SIMD128-NEXT: f64x2.eq $push[[T0:[0-9]+]]=, $0, $0{{$}} 1709; SIMD128-NEXT: f64x2.eq $push[[T1:[0-9]+]]=, $1, $1{{$}} 1710; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1711; SIMD128-NEXT: return $pop[[R]]{{$}} 1712define <2 x i64> @compare_sext_ord_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1713 %cmp = fcmp nnan ord <2 x double> %x, %y 1714 %res = sext <2 x i1> %cmp to <2 x i64> 1715 ret <2 x i64> %res 1716} 1717 1718; CHECK-LABEL: compare_ueq_v2f64: 1719; NO-SIMD128-NOT: f64x2 1720; SIMD128-NEXT: .functype compare_ueq_v2f64 (v128, v128) -> (v128){{$}} 1721; SIMD128-NEXT: f64x2.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1722; SIMD128-NEXT: f64x2.lt $push[[T1:[0-9]+]]=, $0, $1{{$}} 1723; SIMD128-NEXT: v128.or $push[[T2:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1724; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T2]]{{$}} 1725; SIMD128-NEXT: return $pop[[R]]{{$}} 1726define <2 x i1> @compare_ueq_v2f64 (<2 x double> %x, <2 x double> %y) { 1727 %res = fcmp ueq <2 x double> %x, %y 1728 ret <2 x i1> %res 1729} 1730 1731; CHECK-LABEL: compare_ueq_nnan_v2f64: 1732; NO-SIMD128-NOT: f64x2 1733; SIMD128-NEXT: .functype compare_ueq_nnan_v2f64 (v128, v128) -> (v128){{$}} 1734; SIMD128-NEXT: f64x2.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 1735; SIMD128-NEXT: return $pop[[R]]{{$}} 1736define <2 x i1> @compare_ueq_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1737 %res = fcmp nnan ueq <2 x double> %x, %y 1738 ret <2 x i1> %res 1739} 1740 1741; CHECK-LABEL: compare_sext_ueq_v2f64: 1742; NO-SIMD128-NOT: f64x2 1743; SIMD128-NEXT: .functype compare_sext_ueq_v2f64 (v128, v128) -> (v128){{$}} 1744; SIMD128-NEXT: f64x2.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1745; SIMD128-NEXT: f64x2.lt $push[[T1:[0-9]+]]=, $0, $1{{$}} 1746; SIMD128-NEXT: v128.or $push[[T2:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1747; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T2]]{{$}} 1748; SIMD128-NEXT: return $pop[[R]]{{$}} 1749define <2 x i64> @compare_sext_ueq_v2f64 (<2 x double> %x, <2 x double> %y) { 1750 %cmp = fcmp ueq <2 x double> %x, %y 1751 %res = sext <2 x i1> %cmp to <2 x i64> 1752 ret <2 x i64> %res 1753} 1754 1755; CHECK-LABEL: compare_sext_ueq_nnan_v2f64: 1756; NO-SIMD128-NOT: f64x2 1757; SIMD128-NEXT: .functype compare_sext_ueq_nnan_v2f64 (v128, v128) -> (v128){{$}} 1758; SIMD128-NEXT: f64x2.eq $push[[R:[0-9]+]]=, $0, $1{{$}} 1759; SIMD128-NEXT: return $pop[[R]]{{$}} 1760define <2 x i64> @compare_sext_ueq_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1761 %cmp = fcmp nnan ueq <2 x double> %x, %y 1762 %res = sext <2 x i1> %cmp to <2 x i64> 1763 ret <2 x i64> %res 1764} 1765 1766; CHECK-LABEL: compare_ugt_v2f64: 1767; NO-SIMD128-NOT: f64x2 1768; SIMD128-NEXT: .functype compare_ugt_v2f64 (v128, v128) -> (v128){{$}} 1769; SIMD128-NEXT: f64x2.le $push[[T0:[0-9]+]]=, $0, $1{{$}} 1770; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1771; SIMD128-NEXT: return $pop[[R]]{{$}} 1772define <2 x i1> @compare_ugt_v2f64 (<2 x double> %x, <2 x double> %y) { 1773 %res = fcmp ugt <2 x double> %x, %y 1774 ret <2 x i1> %res 1775} 1776 1777; CHECK-LABEL: compare_ugt_nnan_v2f64: 1778; NO-SIMD128-NOT: f64x2 1779; SIMD128-NEXT: .functype compare_ugt_nnan_v2f64 (v128, v128) -> (v128){{$}} 1780; SIMD128-NEXT: f64x2.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 1781; SIMD128-NEXT: return $pop[[R]]{{$}} 1782define <2 x i1> @compare_ugt_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1783 %res = fcmp nnan ugt <2 x double> %x, %y 1784 ret <2 x i1> %res 1785} 1786 1787; CHECK-LABEL: compare_sext_ugt_v2f64: 1788; NO-SIMD128-NOT: f64x2 1789; SIMD128-NEXT: .functype compare_sext_ugt_v2f64 (v128, v128) -> (v128){{$}} 1790; SIMD128-NEXT: f64x2.le $push[[T0:[0-9]+]]=, $0, $1{{$}} 1791; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1792; SIMD128-NEXT: return $pop[[R]]{{$}} 1793define <2 x i64> @compare_sext_ugt_v2f64 (<2 x double> %x, <2 x double> %y) { 1794 %cmp = fcmp ugt <2 x double> %x, %y 1795 %res = sext <2 x i1> %cmp to <2 x i64> 1796 ret <2 x i64> %res 1797} 1798 1799; CHECK-LABEL: compare_sext_ugt_nnan_v2f64: 1800; NO-SIMD128-NOT: f64x2 1801; SIMD128-NEXT: .functype compare_sext_ugt_nnan_v2f64 (v128, v128) -> (v128){{$}} 1802; SIMD128-NEXT: f64x2.gt $push[[R:[0-9]+]]=, $0, $1{{$}} 1803; SIMD128-NEXT: return $pop[[R]]{{$}} 1804define <2 x i64> @compare_sext_ugt_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1805 %cmp = fcmp nnan ugt <2 x double> %x, %y 1806 %res = sext <2 x i1> %cmp to <2 x i64> 1807 ret <2 x i64> %res 1808} 1809 1810; CHECK-LABEL: compare_uge_v2f64: 1811; NO-SIMD128-NOT: f64x2 1812; SIMD128-NEXT: .functype compare_uge_v2f64 (v128, v128) -> (v128){{$}} 1813; SIMD128-NEXT: f64x2.lt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1814; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1815; SIMD128-NEXT: return $pop[[R]]{{$}} 1816define <2 x i1> @compare_uge_v2f64 (<2 x double> %x, <2 x double> %y) { 1817 %res = fcmp uge <2 x double> %x, %y 1818 ret <2 x i1> %res 1819} 1820 1821; CHECK-LABEL: compare_uge_nnan_v2f64: 1822; NO-SIMD128-NOT: f64x2 1823; SIMD128-NEXT: .functype compare_uge_nnan_v2f64 (v128, v128) -> (v128){{$}} 1824; SIMD128-NEXT: f64x2.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 1825; SIMD128-NEXT: return $pop[[R]]{{$}} 1826define <2 x i1> @compare_uge_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1827 %res = fcmp nnan uge <2 x double> %x, %y 1828 ret <2 x i1> %res 1829} 1830 1831; CHECK-LABEL: compare_sext_uge_v2f64: 1832; NO-SIMD128-NOT: f64x2 1833; SIMD128-NEXT: .functype compare_sext_uge_v2f64 (v128, v128) -> (v128){{$}} 1834; SIMD128-NEXT: f64x2.lt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1835; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1836; SIMD128-NEXT: return $pop[[R]]{{$}} 1837define <2 x i64> @compare_sext_uge_v2f64 (<2 x double> %x, <2 x double> %y) { 1838 %cmp = fcmp uge <2 x double> %x, %y 1839 %res = sext <2 x i1> %cmp to <2 x i64> 1840 ret <2 x i64> %res 1841} 1842 1843; CHECK-LABEL: compare_sext_uge_nnan_v2f64: 1844; NO-SIMD128-NOT: f64x2 1845; SIMD128-NEXT: .functype compare_sext_uge_nnan_v2f64 (v128, v128) -> (v128){{$}} 1846; SIMD128-NEXT: f64x2.ge $push[[R:[0-9]+]]=, $0, $1{{$}} 1847; SIMD128-NEXT: return $pop[[R]]{{$}} 1848define <2 x i64> @compare_sext_uge_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1849 %cmp = fcmp nnan uge <2 x double> %x, %y 1850 %res = sext <2 x i1> %cmp to <2 x i64> 1851 ret <2 x i64> %res 1852} 1853 1854; CHECK-LABEL: compare_ult_v2f64: 1855; NO-SIMD128-NOT: f64x2 1856; SIMD128-NEXT: .functype compare_ult_v2f64 (v128, v128) -> (v128){{$}} 1857; SIMD128-NEXT: f64x2.ge $push[[T0:[0-9]+]]=, $0, $1{{$}} 1858; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1859; SIMD128-NEXT: return $pop[[R]]{{$}} 1860define <2 x i1> @compare_ult_v2f64 (<2 x double> %x, <2 x double> %y) { 1861 %res = fcmp ult <2 x double> %x, %y 1862 ret <2 x i1> %res 1863} 1864 1865; CHECK-LABEL: compare_ult_nnan_v2f64: 1866; NO-SIMD128-NOT: f64x2 1867; SIMD128-NEXT: .functype compare_ult_nnan_v2f64 (v128, v128) -> (v128){{$}} 1868; SIMD128-NEXT: f64x2.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 1869; SIMD128-NEXT: return $pop[[R]]{{$}} 1870define <2 x i1> @compare_ult_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1871 %res = fcmp nnan ult <2 x double> %x, %y 1872 ret <2 x i1> %res 1873} 1874 1875; CHECK-LABEL: compare_sext_ult_v2f64: 1876; NO-SIMD128-NOT: f64x2 1877; SIMD128-NEXT: .functype compare_sext_ult_v2f64 (v128, v128) -> (v128){{$}} 1878; SIMD128-NEXT: f64x2.ge $push[[T0:[0-9]+]]=, $0, $1{{$}} 1879; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1880; SIMD128-NEXT: return $pop[[R]]{{$}} 1881define <2 x i64> @compare_sext_ult_v2f64 (<2 x double> %x, <2 x double> %y) { 1882 %cmp = fcmp ult <2 x double> %x, %y 1883 %res = sext <2 x i1> %cmp to <2 x i64> 1884 ret <2 x i64> %res 1885} 1886 1887; CHECK-LABEL: compare_sext_ult_nnan_v2f64: 1888; NO-SIMD128-NOT: f64x2 1889; SIMD128-NEXT: .functype compare_sext_ult_nnan_v2f64 (v128, v128) -> (v128){{$}} 1890; SIMD128-NEXT: f64x2.lt $push[[R:[0-9]+]]=, $0, $1{{$}} 1891; SIMD128-NEXT: return $pop[[R]]{{$}} 1892define <2 x i64> @compare_sext_ult_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1893 %cmp = fcmp nnan ult <2 x double> %x, %y 1894 %res = sext <2 x i1> %cmp to <2 x i64> 1895 ret <2 x i64> %res 1896} 1897 1898; CHECK-LABEL: compare_ule_v2f64: 1899; NO-SIMD128-NOT: f64x2 1900; SIMD128-NEXT: .functype compare_ule_v2f64 (v128, v128) -> (v128){{$}} 1901; SIMD128-NEXT: f64x2.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1902; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1903; SIMD128-NEXT: return $pop[[R]]{{$}} 1904define <2 x i1> @compare_ule_v2f64 (<2 x double> %x, <2 x double> %y) { 1905 %res = fcmp ule <2 x double> %x, %y 1906 ret <2 x i1> %res 1907} 1908 1909; CHECK-LABEL: compare_ule_nnan_v2f64: 1910; NO-SIMD128-NOT: f64x2 1911; SIMD128-NEXT: .functype compare_ule_nnan_v2f64 (v128, v128) -> (v128){{$}} 1912; SIMD128-NEXT: f64x2.le $push[[R:[0-9]+]]=, $0, $1{{$}} 1913; SIMD128-NEXT: return $pop[[R]]{{$}} 1914define <2 x i1> @compare_ule_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1915 %res = fcmp nnan ule <2 x double> %x, %y 1916 ret <2 x i1> %res 1917} 1918 1919; CHECK-LABEL: compare_sext_ule_v2f64: 1920; NO-SIMD128-NOT: f64x2 1921; SIMD128-NEXT: .functype compare_sext_ule_v2f64 (v128, v128) -> (v128){{$}} 1922; SIMD128-NEXT: f64x2.gt $push[[T0:[0-9]+]]=, $0, $1{{$}} 1923; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}} 1924; SIMD128-NEXT: return $pop[[R]]{{$}} 1925define <2 x i64> @compare_sext_ule_v2f64 (<2 x double> %x, <2 x double> %y) { 1926 %cmp = fcmp ule <2 x double> %x, %y 1927 %res = sext <2 x i1> %cmp to <2 x i64> 1928 ret <2 x i64> %res 1929} 1930 1931; CHECK-LABEL: compare_sext_ule_nnan_v2f64: 1932; NO-SIMD128-NOT: f64x2 1933; SIMD128-NEXT: .functype compare_sext_ule_nnan_v2f64 (v128, v128) -> (v128){{$}} 1934; SIMD128-NEXT: f64x2.le $push[[R:[0-9]+]]=, $0, $1{{$}} 1935; SIMD128-NEXT: return $pop[[R]]{{$}} 1936define <2 x i64> @compare_sext_ule_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1937 %cmp = fcmp nnan ule <2 x double> %x, %y 1938 %res = sext <2 x i1> %cmp to <2 x i64> 1939 ret <2 x i64> %res 1940} 1941 1942; CHECK-LABEL: compare_une_v2f64: 1943; NO-SIMD128-NOT: f64x2 1944; SIMD128-NEXT: .functype compare_une_v2f64 (v128, v128) -> (v128){{$}} 1945; SIMD128-NEXT: f64x2.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1946; SIMD128-NEXT: return $pop[[R]]{{$}} 1947define <2 x i1> @compare_une_v2f64 (<2 x double> %x, <2 x double> %y) { 1948 %res = fcmp une <2 x double> %x, %y 1949 ret <2 x i1> %res 1950} 1951 1952; CHECK-LABEL: compare_une_nnan_v2f64: 1953; NO-SIMD128-NOT: f64x2 1954; SIMD128-NEXT: .functype compare_une_nnan_v2f64 (v128, v128) -> (v128){{$}} 1955; SIMD128-NEXT: f64x2.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1956; SIMD128-NEXT: return $pop[[R]]{{$}} 1957define <2 x i1> @compare_une_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1958 %res = fcmp nnan une <2 x double> %x, %y 1959 ret <2 x i1> %res 1960} 1961 1962; CHECK-LABEL: compare_sext_une_v2f64: 1963; NO-SIMD128-NOT: f64x2 1964; SIMD128-NEXT: .functype compare_sext_une_v2f64 (v128, v128) -> (v128){{$}} 1965; SIMD128-NEXT: f64x2.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1966; SIMD128-NEXT: return $pop[[R]]{{$}} 1967define <2 x i64> @compare_sext_une_v2f64 (<2 x double> %x, <2 x double> %y) { 1968 %cmp = fcmp une <2 x double> %x, %y 1969 %res = sext <2 x i1> %cmp to <2 x i64> 1970 ret <2 x i64> %res 1971} 1972 1973; CHECK-LABEL: compare_sext_une_nnan_v2f64: 1974; NO-SIMD128-NOT: f64x2 1975; SIMD128-NEXT: .functype compare_sext_une_nnan_v2f64 (v128, v128) -> (v128){{$}} 1976; SIMD128-NEXT: f64x2.ne $push[[R:[0-9]+]]=, $0, $1{{$}} 1977; SIMD128-NEXT: return $pop[[R]]{{$}} 1978define <2 x i64> @compare_sext_une_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 1979 %cmp = fcmp nnan une <2 x double> %x, %y 1980 %res = sext <2 x i1> %cmp to <2 x i64> 1981 ret <2 x i64> %res 1982} 1983 1984; CHECK-LABEL: compare_uno_v2f64: 1985; NO-SIMD128-NOT: f64x2 1986; SIMD128-NEXT: .functype compare_uno_v2f64 (v128, v128) -> (v128){{$}} 1987; SIMD128-NEXT: f64x2.ne $push[[T0:[0-9]+]]=, $0, $0{{$}} 1988; SIMD128-NEXT: f64x2.ne $push[[T1:[0-9]+]]=, $1, $1{{$}} 1989; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 1990; SIMD128-NEXT: return $pop[[R]]{{$}} 1991define <2 x i1> @compare_uno_v2f64 (<2 x double> %x, <2 x double> %y) { 1992 %res = fcmp uno <2 x double> %x, %y 1993 ret <2 x i1> %res 1994} 1995 1996; CHECK-LABEL: compare_uno_nnan_v2f64: 1997; NO-SIMD128-NOT: f64x2 1998; SIMD128-NEXT: .functype compare_uno_nnan_v2f64 (v128, v128) -> (v128){{$}} 1999; SIMD128-NEXT: f64x2.ne $push[[T0:[0-9]+]]=, $0, $0{{$}} 2000; SIMD128-NEXT: f64x2.ne $push[[T1:[0-9]+]]=, $1, $1{{$}} 2001; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 2002; SIMD128-NEXT: return $pop[[R]]{{$}} 2003define <2 x i1> @compare_uno_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 2004 %res = fcmp nnan uno <2 x double> %x, %y 2005 ret <2 x i1> %res 2006} 2007 2008; CHECK-LABEL: compare_sext_uno_v2f64: 2009; NO-SIMD128-NOT: f64x2 2010; SIMD128-NEXT: .functype compare_sext_uno_v2f64 (v128, v128) -> (v128){{$}} 2011; SIMD128-NEXT: f64x2.ne $push[[T0:[0-9]+]]=, $0, $0{{$}} 2012; SIMD128-NEXT: f64x2.ne $push[[T1:[0-9]+]]=, $1, $1{{$}} 2013; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 2014; SIMD128-NEXT: return $pop[[R]]{{$}} 2015define <2 x i64> @compare_sext_uno_v2f64 (<2 x double> %x, <2 x double> %y) { 2016 %cmp = fcmp uno <2 x double> %x, %y 2017 %res = sext <2 x i1> %cmp to <2 x i64> 2018 ret <2 x i64> %res 2019} 2020 2021; CHECK-LABEL: compare_sext_uno_nnan_v2f64: 2022; NO-SIMD128-NOT: f64x2 2023; SIMD128-NEXT: .functype compare_sext_uno_nnan_v2f64 (v128, v128) -> (v128){{$}} 2024; SIMD128-NEXT: f64x2.ne $push[[T0:[0-9]+]]=, $0, $0{{$}} 2025; SIMD128-NEXT: f64x2.ne $push[[T1:[0-9]+]]=, $1, $1{{$}} 2026; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}} 2027; SIMD128-NEXT: return $pop[[R]]{{$}} 2028define <2 x i64> @compare_sext_uno_nnan_v2f64 (<2 x double> %x, <2 x double> %y) { 2029 %cmp = fcmp nnan uno <2 x double> %x, %y 2030 %res = sext <2 x i1> %cmp to <2 x i64> 2031 ret <2 x i64> %res 2032} 2033