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