test/CodeGen/WebAssembly/simd-comparisons.ll

   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 --check-prefixes CHECK,SIMD128-VM
   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
   7 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
   8 target 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]]{{$}}
  15 define <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]]{{$}}
  25 define <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]]{{$}}
  36 define <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]]{{$}}
  46 define <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]]{{$}}
  57 define <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]]{{$}}
  67 define <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]]{{$}}
  78 define <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]]{{$}}
  88 define <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]]{{$}}
  99 define <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]]{{$}}
 109 define <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]]{{$}}
 120 define <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]]{{$}}
 130 define <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]]{{$}}
 141 define <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]]{{$}}
 151 define <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]]{{$}}
 162 define <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]]{{$}}
 172 define <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]]{{$}}
 183 define <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]]{{$}}
 193 define <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]]{{$}}
 204 define <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]]{{$}}
 214 define <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]]{{$}}
 225 define <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]]{{$}}
 235 define <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]]{{$}}
 246 define <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]]{{$}}
 256 define <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]]{{$}}
 267 define <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]]{{$}}
 277 define <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]]{{$}}
 288 define <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]]{{$}}
 298 define <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]]{{$}}
 309 define <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]]{{$}}
 319 define <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]]{{$}}
 330 define <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]]{{$}}
 340 define <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]]{{$}}
 351 define <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]]{{$}}
 361 define <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]]{{$}}
 372 define <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]]{{$}}
 382 define <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]]{{$}}
 393 define <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]]{{$}}
 403 define <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]]{{$}}
 414 define <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]]{{$}}
 424 define <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]]{{$}}
 435 define <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]]{{$}}
 445 define <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]]{{$}}
 456 define <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]]{{$}}
 466 define <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]]{{$}}
 477 define <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]]{{$}}
 487 define <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]]{{$}}
 498 define <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]]{{$}}
 508 define <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]]{{$}}
 519 define <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]]{{$}}
 529 define <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]]{{$}}
 540 define <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]]{{$}}
 550 define <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]]{{$}}
 561 define <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]]{{$}}
 571 define <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]]{{$}}
 582 define <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]]{{$}}
 592 define <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]]{{$}}
 603 define <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]]{{$}}
 613 define <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]]{{$}}
 624 define <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]]{{$}}
 634 define <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_oeq_v4f32:
 641 ; NO-SIMD128-NOT: f32x4
 642 ; SIMD128-NEXT: .functype compare_oeq_v4f32 (v128, v128) -> (v128){{$}}
 643 ; SIMD128-NEXT: f32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}}
 644 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 645 define <4 x i1> @compare_oeq_v4f32 (<4 x float> %x, <4 x float> %y) {
 646   %res = fcmp oeq <4 x float> %x, %y
 647   ret <4 x i1> %res
 648 }
 649
 650 ; CHECK-LABEL: compare_sext_oeq_v4f32:
 651 ; NO-SIMD128-NOT: f32x4
 652 ; SIMD128-NEXT: .functype compare_sext_oeq_v4f32 (v128, v128) -> (v128){{$}}
 653 ; SIMD128-NEXT: f32x4.eq $push[[R:[0-9]+]]=, $0, $1{{$}}
 654 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 655 define <4 x i32> @compare_sext_oeq_v4f32 (<4 x float> %x, <4 x float> %y) {
 656   %cmp = fcmp oeq <4 x float> %x, %y
 657   %res = sext <4 x i1> %cmp to <4 x i32>
 658   ret <4 x i32> %res
 659 }
 660
 661 ; CHECK-LABEL: compare_ogt_v4f32:
 662 ; NO-SIMD128-NOT: f32x4
 663 ; SIMD128-NEXT: .functype compare_ogt_v4f32 (v128, v128) -> (v128){{$}}
 664 ; SIMD128-NEXT: f32x4.gt $push[[R:[0-9]+]]=, $0, $1{{$}}
 665 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 666 define <4 x i1> @compare_ogt_v4f32 (<4 x float> %x, <4 x float> %y) {
 667   %res = fcmp ogt <4 x float> %x, %y
 668   ret <4 x i1> %res
 669 }
 670
 671 ; CHECK-LABEL: compare_sext_ogt_v4f32:
 672 ; NO-SIMD128-NOT: f32x4
 673 ; SIMD128-NEXT: .functype compare_sext_ogt_v4f32 (v128, v128) -> (v128){{$}}
 674 ; SIMD128-NEXT: f32x4.gt $push[[R:[0-9]+]]=, $0, $1{{$}}
 675 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 676 define <4 x i32> @compare_sext_ogt_v4f32 (<4 x float> %x, <4 x float> %y) {
 677   %cmp = fcmp ogt <4 x float> %x, %y
 678   %res = sext <4 x i1> %cmp to <4 x i32>
 679   ret <4 x i32> %res
 680 }
 681
 682 ; CHECK-LABEL: compare_oge_v4f32:
 683 ; NO-SIMD128-NOT: f32x4
 684 ; SIMD128-NEXT: .functype compare_oge_v4f32 (v128, v128) -> (v128){{$}}
 685 ; SIMD128-NEXT: f32x4.ge $push[[R:[0-9]+]]=, $0, $1{{$}}
 686 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 687 define <4 x i1> @compare_oge_v4f32 (<4 x float> %x, <4 x float> %y) {
 688   %res = fcmp oge <4 x float> %x, %y
 689   ret <4 x i1> %res
 690 }
 691
 692 ; CHECK-LABEL: compare_sext_oge_v4f32:
 693 ; NO-SIMD128-NOT: f32x4
 694 ; SIMD128-NEXT: .functype compare_sext_oge_v4f32 (v128, v128) -> (v128){{$}}
 695 ; SIMD128-NEXT: f32x4.ge $push[[R:[0-9]+]]=, $0, $1{{$}}
 696 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 697 define <4 x i32> @compare_sext_oge_v4f32 (<4 x float> %x, <4 x float> %y) {
 698   %cmp = fcmp oge <4 x float> %x, %y
 699   %res = sext <4 x i1> %cmp to <4 x i32>
 700   ret <4 x i32> %res
 701 }
 702
 703 ; CHECK-LABEL: compare_olt_v4f32:
 704 ; NO-SIMD128-NOT: f32x4
 705 ; SIMD128-NEXT: .functype compare_olt_v4f32 (v128, v128) -> (v128){{$}}
 706 ; SIMD128-NEXT: f32x4.lt $push[[R:[0-9]+]]=, $0, $1{{$}}
 707 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 708 define <4 x i1> @compare_olt_v4f32 (<4 x float> %x, <4 x float> %y) {
 709   %res = fcmp olt <4 x float> %x, %y
 710   ret <4 x i1> %res
 711 }
 712
 713 ; CHECK-LABEL: compare_sext_olt_v4f32:
 714 ; NO-SIMD128-NOT: f32x4
 715 ; SIMD128-NEXT: .functype compare_sext_olt_v4f32 (v128, v128) -> (v128){{$}}
 716 ; SIMD128-NEXT: f32x4.lt $push[[R:[0-9]+]]=, $0, $1{{$}}
 717 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 718 define <4 x i32> @compare_sext_olt_v4f32 (<4 x float> %x, <4 x float> %y) {
 719   %cmp = fcmp olt <4 x float> %x, %y
 720   %res = sext <4 x i1> %cmp to <4 x i32>
 721   ret <4 x i32> %res
 722 }
 723
 724 ; CHECK-LABEL: compare_ole_v4f32:
 725 ; NO-SIMD128-NOT: f32x4
 726 ; SIMD128-NEXT: .functype compare_ole_v4f32 (v128, v128) -> (v128){{$}}
 727 ; SIMD128-NEXT: f32x4.le $push[[R:[0-9]+]]=, $0, $1{{$}}
 728 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 729 define <4 x i1> @compare_ole_v4f32 (<4 x float> %x, <4 x float> %y) {
 730   %res = fcmp ole <4 x float> %x, %y
 731   ret <4 x i1> %res
 732 }
 733
 734 ; CHECK-LABEL: compare_sext_ole_v4f32:
 735 ; NO-SIMD128-NOT: f32x4
 736 ; SIMD128-NEXT: .functype compare_sext_ole_v4f32 (v128, v128) -> (v128){{$}}
 737 ; SIMD128-NEXT: f32x4.le $push[[R:[0-9]+]]=, $0, $1{{$}}
 738 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 739 define <4 x i32> @compare_sext_ole_v4f32 (<4 x float> %x, <4 x float> %y) {
 740   %cmp = fcmp ole <4 x float> %x, %y
 741   %res = sext <4 x i1> %cmp to <4 x i32>
 742   ret <4 x i32> %res
 743 }
 744
 745 ; CHECK-LABEL: compare_one_v4f32:
 746 ; NO-SIMD128-NOT: f32x4
 747 ; SIMD128-NEXT: .functype compare_one_v4f32 (v128, v128) -> (v128){{$}}
 748 ; SIMD128-NEXT: f32x4.ne $push[[T0:[0-9]+]]=, $0, $1{{$}}
 749 ; SIMD128-NEXT: f32x4.eq $push[[T1:[0-9]+]]=, $0, $0{{$}}
 750 ; SIMD128-NEXT: f32x4.eq $push[[T2:[0-9]+]]=, $1, $1{{$}}
 751 ; SIMD128-NEXT: v128.and $push[[T3:[0-9]+]]=, $pop[[T1]], $pop[[T2]]{{$}}
 752 ; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T3]]{{$}}
 753 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 754 define <4 x i1> @compare_one_v4f32 (<4 x float> %x, <4 x float> %y) {
 755   %res = fcmp one <4 x float> %x, %y
 756   ret <4 x i1> %res
 757 }
 758
 759 ; CHECK-LABEL: compare_sext_one_v4f32:
 760 ; NO-SIMD128-NOT: f32x4
 761 ; SIMD128-NEXT: .functype compare_sext_one_v4f32 (v128, v128) -> (v128){{$}}
 762 ; SIMD128-NEXT: f32x4.ne $push[[T0:[0-9]+]]=, $0, $1{{$}}
 763 ; SIMD128-NEXT: f32x4.eq $push[[T1:[0-9]+]]=, $0, $0{{$}}
 764 ; SIMD128-NEXT: f32x4.eq $push[[T2:[0-9]+]]=, $1, $1{{$}}
 765 ; SIMD128-NEXT: v128.and $push[[T3:[0-9]+]]=, $pop[[T1]], $pop[[T2]]{{$}}
 766 ; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T3]]{{$}}
 767 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 768 define <4 x i32> @compare_sext_one_v4f32 (<4 x float> %x, <4 x float> %y) {
 769   %cmp = fcmp one <4 x float> %x, %y
 770   %res = sext <4 x i1> %cmp to <4 x i32>
 771   ret <4 x i32> %res
 772 }
 773
 774 ; CHECK-LABEL: compare_ord_v4f32:
 775 ; NO-SIMD128-NOT: f32x4
 776 ; SIMD128-NEXT: .functype compare_ord_v4f32 (v128, v128) -> (v128){{$}}
 777 ; SIMD128-NEXT: f32x4.eq $push[[T0:[0-9]+]]=, $0, $0{{$}}
 778 ; SIMD128-NEXT: f32x4.eq $push[[T1:[0-9]+]]=, $1, $1{{$}}
 779 ; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}}
 780 ; SIMD128-NEXT: return   $pop[[R]]{{$}}
 781 define <4 x i1> @compare_ord_v4f32 (<4 x float> %x, <4 x float> %y) {
 782   %res = fcmp ord <4 x float> %x, %y
 783   ret <4 x i1> %res
 784 }
 785
 786 ; CHECK-LABEL: compare_sext_ord_v4f32:
 787 ; NO-SIMD128-NOT: f32x4
 788 ; SIMD128-NEXT: .functype compare_sext_ord_v4f32 (v128, v128) -> (v128){{$}}
 789 ; SIMD128-NEXT: f32x4.eq $push[[T0:[0-9]+]]=, $0, $0{{$}}
 790 ; SIMD128-NEXT: f32x4.eq $push[[T1:[0-9]+]]=, $1, $1{{$}}
 791 ; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}}
 792 ; SIMD128-NEXT: return   $pop[[R]]{{$}}
 793 define <4 x i32> @compare_sext_ord_v4f32 (<4 x float> %x, <4 x float> %y) {
 794   %cmp = fcmp ord <4 x float> %x, %y
 795   %res = sext <4 x i1> %cmp to <4 x i32>
 796   ret <4 x i32> %res
 797 }
 798
 799 ; CHECK-LABEL: compare_ueq_v4f32:
 800 ; NO-SIMD128-NOT: f32x4
 801 ; SIMD128-NEXT: .functype compare_ueq_v4f32 (v128, v128) -> (v128){{$}}
 802 ; SIMD128-NEXT: f32x4.eq $push[[T0:[0-9]+]]=, $0, $1{{$}}
 803 ; SIMD128-NEXT: f32x4.ne $push[[T1:[0-9]+]]=, $0, $0{{$}}
 804 ; SIMD128-NEXT: f32x4.ne $push[[T2:[0-9]+]]=, $1, $1{{$}}
 805 ; SIMD128-NEXT: v128.or $push[[T3:[0-9]+]]=, $pop[[T1]], $pop[[T2]]{{$}}
 806 ; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T3]]{{$}}
 807 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 808 define <4 x i1> @compare_ueq_v4f32 (<4 x float> %x, <4 x float> %y) {
 809   %res = fcmp ueq <4 x float> %x, %y
 810   ret <4 x i1> %res
 811 }
 812
 813 ; CHECK-LABEL: compare_sext_ueq_v4f32:
 814 ; NO-SIMD128-NOT: f32x4
 815 ; SIMD128-NEXT: .functype compare_sext_ueq_v4f32 (v128, v128) -> (v128){{$}}
 816 ; SIMD128-NEXT: f32x4.eq $push[[T0:[0-9]+]]=, $0, $1{{$}}
 817 ; SIMD128-NEXT: f32x4.ne $push[[T1:[0-9]+]]=, $0, $0{{$}}
 818 ; SIMD128-NEXT: f32x4.ne $push[[T2:[0-9]+]]=, $1, $1{{$}}
 819 ; SIMD128-NEXT: v128.or $push[[T3:[0-9]+]]=, $pop[[T1]], $pop[[T2]]{{$}}
 820 ; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T3]]{{$}}
 821 ; SIMD128-NEXT: return $pop[[R]]
 822 define <4 x i32> @compare_sext_ueq_v4f32 (<4 x float> %x, <4 x float> %y) {
 823   %cmp = fcmp ueq <4 x float> %x, %y
 824   %res = sext <4 x i1> %cmp to <4 x i32>
 825   ret <4 x i32> %res
 826 }
 827
 828 ; CHECK-LABEL: compare_ugt_v4f32:
 829 ; NO-SIMD128-NOT: f32x4
 830 ; SIMD128-NEXT: .functype compare_ugt_v4f32 (v128, v128) -> (v128){{$}}
 831 ; SIMD128-NEXT: f32x4.le $push[[T0:[0-9]+]]=, $0, $1{{$}}
 832 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
 833 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 834 define <4 x i1> @compare_ugt_v4f32 (<4 x float> %x, <4 x float> %y) {
 835   %res = fcmp ugt <4 x float> %x, %y
 836   ret <4 x i1> %res
 837 }
 838
 839 ; CHECK-LABEL: compare_sext_ugt_v4f32:
 840 ; NO-SIMD128-NOT: f32x4
 841 ; SIMD128-NEXT: .functype compare_sext_ugt_v4f32 (v128, v128) -> (v128){{$}}
 842 ; SIMD128-NEXT: f32x4.le $push[[T0:[0-9]+]]=, $0, $1{{$}}
 843 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
 844 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 845 define <4 x i32> @compare_sext_ugt_v4f32 (<4 x float> %x, <4 x float> %y) {
 846   %cmp = fcmp ugt <4 x float> %x, %y
 847   %res = sext <4 x i1> %cmp to <4 x i32>
 848   ret <4 x i32> %res
 849 }
 850
 851 ; CHECK-LABEL: compare_uge_v4f32:
 852 ; NO-SIMD128-NOT: f32x4
 853 ; SIMD128-NEXT: .functype compare_uge_v4f32 (v128, v128) -> (v128){{$}}
 854 ; SIMD128-NEXT: f32x4.lt $push[[T0:[0-9]+]]=, $0, $1{{$}}
 855 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
 856 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 857 define <4 x i1> @compare_uge_v4f32 (<4 x float> %x, <4 x float> %y) {
 858   %res = fcmp uge <4 x float> %x, %y
 859   ret <4 x i1> %res
 860 }
 861
 862 ; CHECK-LABEL: compare_sext_uge_v4f32:
 863 ; NO-SIMD128-NOT: f32x4
 864 ; SIMD128-NEXT: .functype compare_sext_uge_v4f32 (v128, v128) -> (v128){{$}}
 865 ; SIMD128-NEXT: f32x4.lt $push[[T0:[0-9]+]]=, $0, $1{{$}}
 866 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
 867 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 868 define <4 x i32> @compare_sext_uge_v4f32 (<4 x float> %x, <4 x float> %y) {
 869   %cmp = fcmp uge <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_ult_v4f32:
 875 ; NO-SIMD128-NOT: f32x4
 876 ; SIMD128-NEXT: .functype compare_ult_v4f32 (v128, v128) -> (v128){{$}}
 877 ; SIMD128-NEXT: f32x4.ge $push[[T0:[0-9]+]]=, $0, $1{{$}}
 878 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
 879 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 880 define <4 x i1> @compare_ult_v4f32 (<4 x float> %x, <4 x float> %y) {
 881   %res = fcmp ult <4 x float> %x, %y
 882   ret <4 x i1> %res
 883 }
 884
 885 ; CHECK-LABEL: compare_sext_ult_v4f32:
 886 ; NO-SIMD128-NOT: f32x4
 887 ; SIMD128-NEXT: .functype compare_sext_ult_v4f32 (v128, v128) -> (v128){{$}}
 888 ; SIMD128-NEXT: f32x4.ge $push[[T0:[0-9]+]]=, $0, $1{{$}}
 889 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
 890 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 891 define <4 x i32> @compare_sext_ult_v4f32 (<4 x float> %x, <4 x float> %y) {
 892   %cmp = fcmp ult <4 x float> %x, %y
 893   %res = sext <4 x i1> %cmp to <4 x i32>
 894   ret <4 x i32> %res
 895 }
 896
 897 ; CHECK-LABEL: compare_ule_v4f32:
 898 ; NO-SIMD128-NOT: f32x4
 899 ; SIMD128-NEXT: .functype compare_ule_v4f32 (v128, v128) -> (v128){{$}}
 900 ; SIMD128-NEXT: f32x4.gt $push[[T0:[0-9]+]]=, $0, $1{{$}}
 901 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
 902 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 903 define <4 x i1> @compare_ule_v4f32 (<4 x float> %x, <4 x float> %y) {
 904   %res = fcmp ule <4 x float> %x, %y
 905   ret <4 x i1> %res
 906 }
 907
 908 ; CHECK-LABEL: compare_sext_ule_v4f32:
 909 ; NO-SIMD128-NOT: f32x4
 910 ; SIMD128-NEXT: .functype compare_sext_ule_v4f32 (v128, v128) -> (v128){{$}}
 911 ; SIMD128-NEXT: f32x4.gt $push[[T0:[0-9]+]]=, $0, $1{{$}}
 912 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
 913 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 914 define <4 x i32> @compare_sext_ule_v4f32 (<4 x float> %x, <4 x float> %y) {
 915   %cmp = fcmp ule <4 x float> %x, %y
 916   %res = sext <4 x i1> %cmp to <4 x i32>
 917   ret <4 x i32> %res
 918 }
 919
 920 ; CHECK-LABEL: compare_une_v4f32:
 921 ; NO-SIMD128-NOT: f32x4
 922 ; SIMD128-NEXT: .functype compare_une_v4f32 (v128, v128) -> (v128){{$}}
 923 ; SIMD128-NEXT: f32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}}{{$}}
 924 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 925 define <4 x i1> @compare_une_v4f32 (<4 x float> %x, <4 x float> %y) {
 926   %res = fcmp une <4 x float> %x, %y
 927   ret <4 x i1> %res
 928 }
 929
 930 ; CHECK-LABEL: compare_sext_une_v4f32:
 931 ; NO-SIMD128-NOT: f32x4
 932 ; SIMD128-NEXT: .functype compare_sext_une_v4f32 (v128, v128) -> (v128){{$}}
 933 ; SIMD128-NEXT: f32x4.ne $push[[R:[0-9]+]]=, $0, $1{{$}}
 934 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 935 define <4 x i32> @compare_sext_une_v4f32 (<4 x float> %x, <4 x float> %y) {
 936   %cmp = fcmp une <4 x float> %x, %y
 937   %res = sext <4 x i1> %cmp to <4 x i32>
 938   ret <4 x i32> %res
 939 }
 940
 941 ; CHECK-LABEL: compare_uno_v4f32:
 942 ; NO-SIMD128-NOT: f32x4
 943 ; SIMD128-NEXT: .functype compare_uno_v4f32 (v128, v128) -> (v128){{$}}
 944 ; SIMD128-NEXT: f32x4.ne $push[[T0:[0-9]+]]=, $0, $0{{$}}
 945 ; SIMD128-NEXT: f32x4.ne $push[[T1:[0-9]+]]=, $1, $1{{$}}
 946 ; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}}
 947 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 948 define <4 x i1> @compare_uno_v4f32 (<4 x float> %x, <4 x float> %y) {
 949   %res = fcmp uno <4 x float> %x, %y
 950   ret <4 x i1> %res
 951 }
 952
 953 ; CHECK-LABEL: compare_sext_uno_v4f32:
 954 ; NO-SIMD128-NOT: f32x4
 955 ; SIMD128-NEXT: .functype compare_sext_uno_v4f32 (v128, v128) -> (v128){{$}}
 956 ; SIMD128-NEXT: f32x4.ne $push[[T0:[0-9]+]]=, $0, $0{{$}}
 957 ; SIMD128-NEXT: f32x4.ne $push[[T1:[0-9]+]]=, $1, $1{{$}}
 958 ; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}}
 959 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 960 define <4 x i32> @compare_sext_uno_v4f32 (<4 x float> %x, <4 x float> %y) {
 961   %cmp = fcmp uno <4 x float> %x, %y
 962   %res = sext <4 x i1> %cmp to <4 x i32>
 963   ret <4 x i32> %res
 964 }
 965
 966 ; CHECK-LABEL: compare_oeq_v2f64:
 967 ; NO-SIMD128-NOT: f64x2
 968 ; SIMD128-VM-NOT: f64x2
 969 ; SIMD128-NEXT: .functype compare_oeq_v2f64 (v128, v128) -> (v128){{$}}
 970 ; SIMD128-NEXT: f64x2.eq $push[[R:[0-9]+]]=, $0, $1{{$}}
 971 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 972 define <2 x i1> @compare_oeq_v2f64 (<2 x double> %x, <2 x double> %y) {
 973   %res = fcmp oeq <2 x double> %x, %y
 974   ret <2 x i1> %res
 975 }
 976
 977 ; CHECK-LABEL: compare_sext_oeq_v2f64:
 978 ; NO-SIMD128-NOT: f64x2
 979 ; SIMD128-VM-NOT: f64x2
 980 ; SIMD128-NEXT: .functype compare_sext_oeq_v2f64 (v128, v128) -> (v128){{$}}
 981 ; SIMD128-NEXT: f64x2.eq $push[[R:[0-9]+]]=, $0, $1{{$}}
 982 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 983 define <2 x i64> @compare_sext_oeq_v2f64 (<2 x double> %x, <2 x double> %y) {
 984   %cmp = fcmp oeq <2 x double> %x, %y
 985   %res = sext <2 x i1> %cmp to <2 x i64>
 986   ret <2 x i64> %res
 987 }
 988
 989 ; CHECK-LABEL: compare_ogt_v2f64:
 990 ; NO-SIMD128-NOT: f64x2
 991 ; SIMD128-VM-NOT: f64x2
 992 ; SIMD128-NEXT: .functype compare_ogt_v2f64 (v128, v128) -> (v128){{$}}
 993 ; SIMD128-NEXT: f64x2.gt $push[[R:[0-9]+]]=, $0, $1{{$}}
 994 ; SIMD128-NEXT: return $pop[[R]]{{$}}
 995 define <2 x i1> @compare_ogt_v2f64 (<2 x double> %x, <2 x double> %y) {
 996   %res = fcmp ogt <2 x double> %x, %y
 997   ret <2 x i1> %res
 998 }
 999
1000 ; CHECK-LABEL: compare_sext_ogt_v2f64:
1001 ; NO-SIMD128-NOT: f64x2
1002 ; SIMD128-VM-NOT: f64x2
1003 ; SIMD128-NEXT: .functype compare_sext_ogt_v2f64 (v128, v128) -> (v128){{$}}
1004 ; SIMD128-NEXT: f64x2.gt $push[[R:[0-9]+]]=, $0, $1{{$}}
1005 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1006 define <2 x i64> @compare_sext_ogt_v2f64 (<2 x double> %x, <2 x double> %y) {
1007   %cmp = fcmp ogt <2 x double> %x, %y
1008   %res = sext <2 x i1> %cmp to <2 x i64>
1009   ret <2 x i64> %res
1010 }
1011
1012 ; CHECK-LABEL: compare_oge_v2f64:
1013 ; NO-SIMD128-NOT: f64x2
1014 ; SIMD128-VM-NOT: f64x2
1015 ; SIMD128-NEXT: .functype compare_oge_v2f64 (v128, v128) -> (v128){{$}}
1016 ; SIMD128-NEXT: f64x2.ge $push[[R:[0-9]+]]=, $0, $1{{$}}
1017 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1018 define <2 x i1> @compare_oge_v2f64 (<2 x double> %x, <2 x double> %y) {
1019   %res = fcmp oge <2 x double> %x, %y
1020   ret <2 x i1> %res
1021 }
1022
1023 ; CHECK-LABEL: compare_sext_oge_v2f64:
1024 ; NO-SIMD128-NOT: f64x2
1025 ; SIMD128-VM-NOT: f64x2
1026 ; SIMD128-NEXT: .functype compare_sext_oge_v2f64 (v128, v128) -> (v128){{$}}
1027 ; SIMD128-NEXT: f64x2.ge $push[[R:[0-9]+]]=, $0, $1{{$}}
1028 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1029 define <2 x i64> @compare_sext_oge_v2f64 (<2 x double> %x, <2 x double> %y) {
1030   %cmp = fcmp oge <2 x double> %x, %y
1031   %res = sext <2 x i1> %cmp to <2 x i64>
1032   ret <2 x i64> %res
1033 }
1034
1035 ; CHECK-LABEL: compare_olt_v2f64:
1036 ; NO-SIMD128-NOT: f64x2
1037 ; SIMD128-VM-NOT: f64x2
1038 ; SIMD128-NEXT: .functype compare_olt_v2f64 (v128, v128) -> (v128){{$}}
1039 ; SIMD128-NEXT: f64x2.lt $push[[R:[0-9]+]]=, $0, $1{{$}}
1040 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1041 define <2 x i1> @compare_olt_v2f64 (<2 x double> %x, <2 x double> %y) {
1042   %res = fcmp olt <2 x double> %x, %y
1043   ret <2 x i1> %res
1044 }
1045
1046 ; CHECK-LABEL: compare_sext_olt_v2f64:
1047 ; NO-SIMD128-NOT: f64x2
1048 ; SIMD128-VM-NOT: f64x2
1049 ; SIMD128-NEXT: .functype compare_sext_olt_v2f64 (v128, v128) -> (v128){{$}}
1050 ; SIMD128-NEXT: f64x2.lt $push[[R:[0-9]+]]=, $0, $1{{$}}
1051 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1052 define <2 x i64> @compare_sext_olt_v2f64 (<2 x double> %x, <2 x double> %y) {
1053   %cmp = fcmp olt <2 x double> %x, %y
1054   %res = sext <2 x i1> %cmp to <2 x i64>
1055   ret <2 x i64> %res
1056 }
1057
1058 ; CHECK-LABEL: compare_ole_v2f64:
1059 ; NO-SIMD128-NOT: f64x2
1060 ; SIMD128-VM-NOT: f64x2
1061 ; SIMD128-NEXT: .functype compare_ole_v2f64 (v128, v128) -> (v128){{$}}
1062 ; SIMD128-NEXT: f64x2.le $push[[R:[0-9]+]]=, $0, $1{{$}}
1063 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1064 define <2 x i1> @compare_ole_v2f64 (<2 x double> %x, <2 x double> %y) {
1065   %res = fcmp ole <2 x double> %x, %y
1066   ret <2 x i1> %res
1067 }
1068
1069 ; CHECK-LABEL: compare_sext_ole_v2f64:
1070 ; NO-SIMD128-NOT: f64x2
1071 ; SIMD128-VM-NOT: f64x2
1072 ; SIMD128-NEXT: .functype compare_sext_ole_v2f64 (v128, v128) -> (v128){{$}}
1073 ; SIMD128-NEXT: f64x2.le $push[[R:[0-9]+]]=, $0, $1{{$}}
1074 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1075 define <2 x i64> @compare_sext_ole_v2f64 (<2 x double> %x, <2 x double> %y) {
1076   %cmp = fcmp ole <2 x double> %x, %y
1077   %res = sext <2 x i1> %cmp to <2 x i64>
1078   ret <2 x i64> %res
1079 }
1080
1081 ; CHECK-LABEL: compare_one_v2f64:
1082 ; NO-SIMD128-NOT: f64x2
1083 ; SIMD128-VM-NOT: f64x2
1084 ; SIMD128-NEXT: .functype compare_one_v2f64 (v128, v128) -> (v128){{$}}
1085 ; SIMD128-NEXT: f64x2.ne $push[[T0:[0-9]+]]=, $0, $1{{$}}
1086 ; SIMD128-NEXT: f64x2.eq $push[[T1:[0-9]+]]=, $0, $0{{$}}
1087 ; SIMD128-NEXT: f64x2.eq $push[[T2:[0-9]+]]=, $1, $1{{$}}
1088 ; SIMD128-NEXT: v128.and $push[[T3:[0-9]+]]=, $pop[[T1]], $pop[[T2]]{{$}}
1089 ; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T3]]{{$}}
1090 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1091 define <2 x i1> @compare_one_v2f64 (<2 x double> %x, <2 x double> %y) {
1092   %res = fcmp one <2 x double> %x, %y
1093   ret <2 x i1> %res
1094 }
1095
1096 ; CHECK-LABEL: compare_sext_one_v2f64:
1097 ; NO-SIMD128-NOT: f64x2
1098 ; SIMD128-VM-NOT: f64x2
1099 ; SIMD128-NEXT: .functype compare_sext_one_v2f64 (v128, v128) -> (v128){{$}}
1100 ; SIMD128-NEXT: f64x2.ne $push[[T0:[0-9]+]]=, $0, $1{{$}}
1101 ; SIMD128-NEXT: f64x2.eq $push[[T1:[0-9]+]]=, $0, $0{{$}}
1102 ; SIMD128-NEXT: f64x2.eq $push[[T2:[0-9]+]]=, $1, $1{{$}}
1103 ; SIMD128-NEXT: v128.and $push[[T3:[0-9]+]]=, $pop[[T1]], $pop[[T2]]{{$}}
1104 ; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T3]]{{$}}
1105 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1106 define <2 x i64> @compare_sext_one_v2f64 (<2 x double> %x, <2 x double> %y) {
1107   %cmp = fcmp one <2 x double> %x, %y
1108   %res = sext <2 x i1> %cmp to <2 x i64>
1109   ret <2 x i64> %res
1110 }
1111
1112 ; CHECK-LABEL: compare_ord_v2f64:
1113 ; NO-SIMD128-NOT: f64x2
1114 ; SIMD128-VM-NOT: f64x2
1115 ; SIMD128-NEXT: .functype compare_ord_v2f64 (v128, v128) -> (v128){{$}}
1116 ; SIMD128-NEXT: f64x2.eq $push[[T0:[0-9]+]]=, $0, $0{{$}}
1117 ; SIMD128-NEXT: f64x2.eq $push[[T1:[0-9]+]]=, $1, $1{{$}}
1118 ; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}}
1119 ; SIMD128-NEXT: return   $pop[[R]]{{$}}
1120 define <2 x i1> @compare_ord_v2f64 (<2 x double> %x, <2 x double> %y) {
1121   %res = fcmp ord <2 x double> %x, %y
1122   ret <2 x i1> %res
1123 }
1124
1125 ; CHECK-LABEL: compare_sext_ord_v2f64:
1126 ; NO-SIMD128-NOT: f64x2
1127 ; SIMD128-VM-NOT: f64x2
1128 ; SIMD128-NEXT: .functype compare_sext_ord_v2f64 (v128, v128) -> (v128){{$}}
1129 ; SIMD128-NEXT: f64x2.eq $push[[T0:[0-9]+]]=, $0, $0{{$}}
1130 ; SIMD128-NEXT: f64x2.eq $push[[T1:[0-9]+]]=, $1, $1{{$}}
1131 ; SIMD128-NEXT: v128.and $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}}
1132 ; SIMD128-NEXT: return   $pop[[R]]{{$}}
1133 define <2 x i64> @compare_sext_ord_v2f64 (<2 x double> %x, <2 x double> %y) {
1134   %cmp = fcmp ord <2 x double> %x, %y
1135   %res = sext <2 x i1> %cmp to <2 x i64>
1136   ret <2 x i64> %res
1137 }
1138
1139 ; CHECK-LABEL: compare_ueq_v2f64:
1140 ; NO-SIMD128-NOT: f64x2
1141 ; SIMD128-VM-NOT: f64x2
1142 ; SIMD128-NEXT: .functype compare_ueq_v2f64 (v128, v128) -> (v128){{$}}
1143 ; SIMD128-NEXT: f64x2.eq $push[[T0:[0-9]+]]=, $0, $1{{$}}
1144 ; SIMD128-NEXT: f64x2.ne $push[[T1:[0-9]+]]=, $0, $0{{$}}
1145 ; SIMD128-NEXT: f64x2.ne $push[[T2:[0-9]+]]=, $1, $1{{$}}
1146 ; SIMD128-NEXT: v128.or $push[[T3:[0-9]+]]=, $pop[[T1]], $pop[[T2]]{{$}}
1147 ; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T3]]{{$}}
1148 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1149 define <2 x i1> @compare_ueq_v2f64 (<2 x double> %x, <2 x double> %y) {
1150   %res = fcmp ueq <2 x double> %x, %y
1151   ret <2 x i1> %res
1152 }
1153
1154 ; CHECK-LABEL: compare_sext_ueq_v2f64:
1155 ; NO-SIMD128-NOT: f64x2
1156 ; SIMD128-VM-NOT: f64x2
1157 ; SIMD128-NEXT: .functype compare_sext_ueq_v2f64 (v128, v128) -> (v128){{$}}
1158 ; SIMD128-NEXT: f64x2.eq $push[[T0:[0-9]+]]=, $0, $1{{$}}
1159 ; SIMD128-NEXT: f64x2.ne $push[[T1:[0-9]+]]=, $0, $0{{$}}
1160 ; SIMD128-NEXT: f64x2.ne $push[[T2:[0-9]+]]=, $1, $1{{$}}
1161 ; SIMD128-NEXT: v128.or $push[[T3:[0-9]+]]=, $pop[[T1]], $pop[[T2]]{{$}}
1162 ; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T3]]{{$}}
1163 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1164 define <2 x i64> @compare_sext_ueq_v2f64 (<2 x double> %x, <2 x double> %y) {
1165   %cmp = fcmp ueq <2 x double> %x, %y
1166   %res = sext <2 x i1> %cmp to <2 x i64>
1167   ret <2 x i64> %res
1168 }
1169
1170 ; CHECK-LABEL: compare_ugt_v2f64:
1171 ; NO-SIMD128-NOT: f64x2
1172 ; SIMD128-VM-NOT: f64x2
1173 ; SIMD128-NEXT: .functype compare_ugt_v2f64 (v128, v128) -> (v128){{$}}
1174 ; SIMD128-NEXT: f64x2.le $push[[T0:[0-9]+]]=, $0, $1{{$}}
1175 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
1176 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1177 define <2 x i1> @compare_ugt_v2f64 (<2 x double> %x, <2 x double> %y) {
1178   %res = fcmp ugt <2 x double> %x, %y
1179   ret <2 x i1> %res
1180 }
1181
1182 ; CHECK-LABEL: compare_sext_ugt_v2f64:
1183 ; NO-SIMD128-NOT: f64x2
1184 ; SIMD128-VM-NOT: f64x2
1185 ; SIMD128-NEXT: .functype compare_sext_ugt_v2f64 (v128, v128) -> (v128){{$}}
1186 ; SIMD128-NEXT: f64x2.le $push[[T0:[0-9]+]]=, $0, $1{{$}}
1187 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
1188 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1189 define <2 x i64> @compare_sext_ugt_v2f64 (<2 x double> %x, <2 x double> %y) {
1190   %cmp = fcmp ugt <2 x double> %x, %y
1191   %res = sext <2 x i1> %cmp to <2 x i64>
1192   ret <2 x i64> %res
1193 }
1194
1195 ; CHECK-LABEL: compare_uge_v2f64:
1196 ; NO-SIMD128-NOT: f64x2
1197 ; SIMD128-VM-NOT: f64x2
1198 ; SIMD128-NEXT: .functype compare_uge_v2f64 (v128, v128) -> (v128){{$}}
1199 ; SIMD128-NEXT: f64x2.lt $push[[T0:[0-9]+]]=, $0, $1{{$}}
1200 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
1201 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1202 define <2 x i1> @compare_uge_v2f64 (<2 x double> %x, <2 x double> %y) {
1203   %res = fcmp uge <2 x double> %x, %y
1204   ret <2 x i1> %res
1205 }
1206
1207 ; CHECK-LABEL: compare_sext_uge_v2f64:
1208 ; NO-SIMD128-NOT: f64x2
1209 ; SIMD128-VM-NOT: f64x2
1210 ; SIMD128-NEXT: .functype compare_sext_uge_v2f64 (v128, v128) -> (v128){{$}}
1211 ; SIMD128-NEXT: f64x2.lt $push[[T0:[0-9]+]]=, $0, $1{{$}}
1212 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
1213 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1214 define <2 x i64> @compare_sext_uge_v2f64 (<2 x double> %x, <2 x double> %y) {
1215   %cmp = fcmp uge <2 x double> %x, %y
1216   %res = sext <2 x i1> %cmp to <2 x i64>
1217   ret <2 x i64> %res
1218 }
1219
1220 ; CHECK-LABEL: compare_ult_v2f64:
1221 ; NO-SIMD128-NOT: f64x2
1222 ; SIMD128-VM-NOT: f64x2
1223 ; SIMD128-NEXT: .functype compare_ult_v2f64 (v128, v128) -> (v128){{$}}
1224 ; SIMD128-NEXT: f64x2.ge $push[[T0:[0-9]+]]=, $0, $1{{$}}
1225 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
1226 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1227 define <2 x i1> @compare_ult_v2f64 (<2 x double> %x, <2 x double> %y) {
1228   %res = fcmp ult <2 x double> %x, %y
1229   ret <2 x i1> %res
1230 }
1231
1232 ; CHECK-LABEL: compare_sext_ult_v2f64:
1233 ; NO-SIMD128-NOT: f64x2
1234 ; SIMD128-VM-NOT: f64x2
1235 ; SIMD128-NEXT: .functype compare_sext_ult_v2f64 (v128, v128) -> (v128){{$}}
1236 ; SIMD128-NEXT: f64x2.ge $push[[T0:[0-9]+]]=, $0, $1{{$}}
1237 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
1238 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1239 define <2 x i64> @compare_sext_ult_v2f64 (<2 x double> %x, <2 x double> %y) {
1240   %cmp = fcmp ult <2 x double> %x, %y
1241   %res = sext <2 x i1> %cmp to <2 x i64>
1242   ret <2 x i64> %res
1243 }
1244
1245 ; CHECK-LABEL: compare_ule_v2f64:
1246 ; NO-SIMD128-NOT: f64x2
1247 ; SIMD128-VM-NOT: f64x2
1248 ; SIMD128-NEXT: .functype compare_ule_v2f64 (v128, v128) -> (v128){{$}}
1249 ; SIMD128-NEXT: f64x2.gt $push[[T0:[0-9]+]]=, $0, $1{{$}}
1250 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
1251 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1252 define <2 x i1> @compare_ule_v2f64 (<2 x double> %x, <2 x double> %y) {
1253   %res = fcmp ule <2 x double> %x, %y
1254   ret <2 x i1> %res
1255 }
1256
1257 ; CHECK-LABEL: compare_sext_ule_v2f64:
1258 ; NO-SIMD128-NOT: f64x2
1259 ; SIMD128-VM-NOT: f64x2
1260 ; SIMD128-NEXT: .functype compare_sext_ule_v2f64 (v128, v128) -> (v128){{$}}
1261 ; SIMD128-NEXT: f64x2.gt $push[[T0:[0-9]+]]=, $0, $1{{$}}
1262 ; SIMD128-NEXT: v128.not $push[[R:[0-9]+]]=, $pop[[T0]]{{$}}
1263 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1264 define <2 x i64> @compare_sext_ule_v2f64 (<2 x double> %x, <2 x double> %y) {
1265   %cmp = fcmp ule <2 x double> %x, %y
1266   %res = sext <2 x i1> %cmp to <2 x i64>
1267   ret <2 x i64> %res
1268 }
1269
1270 ; CHECK-LABEL: compare_une_v2f64:
1271 ; NO-SIMD128-NOT: f64x2
1272 ; SIMD128-VM-NOT: f64x2
1273 ; SIMD128-NEXT: .functype compare_une_v2f64 (v128, v128) -> (v128){{$}}
1274 ; SIMD128-NEXT: f64x2.ne $push[[R:[0-9]+]]=, $0, $1{{$}}
1275 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1276 define <2 x i1> @compare_une_v2f64 (<2 x double> %x, <2 x double> %y) {
1277   %res = fcmp une <2 x double> %x, %y
1278   ret <2 x i1> %res
1279 }
1280
1281 ; CHECK-LABEL: compare_sext_une_v2f64:
1282 ; NO-SIMD128-NOT: f64x2
1283 ; SIMD128-VM-NOT: f64x2
1284 ; SIMD128-NEXT: .functype compare_sext_une_v2f64 (v128, v128) -> (v128){{$}}
1285 ; SIMD128-NEXT: f64x2.ne $push[[R:[0-9]+]]=, $0, $1{{$}}
1286 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1287 define <2 x i64> @compare_sext_une_v2f64 (<2 x double> %x, <2 x double> %y) {
1288   %cmp = fcmp une <2 x double> %x, %y
1289   %res = sext <2 x i1> %cmp to <2 x i64>
1290   ret <2 x i64> %res
1291 }
1292
1293 ; CHECK-LABEL: compare_uno_v2f64:
1294 ; NO-SIMD128-NOT: f64x2
1295 ; SIMD128-VM-NOT: f64x2
1296 ; SIMD128-NEXT: .functype compare_uno_v2f64 (v128, v128) -> (v128){{$}}
1297 ; SIMD128-NEXT: f64x2.ne $push[[T0:[0-9]+]]=, $0, $0{{$}}
1298 ; SIMD128-NEXT: f64x2.ne $push[[T1:[0-9]+]]=, $1, $1{{$}}
1299 ; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}}
1300 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1301 define <2 x i1> @compare_uno_v2f64 (<2 x double> %x, <2 x double> %y) {
1302   %res = fcmp uno <2 x double> %x, %y
1303   ret <2 x i1> %res
1304 }
1305
1306 ; CHECK-LABEL: compare_sext_uno_v2f64:
1307 ; NO-SIMD128-NOT: f64x2
1308 ; SIMD128-VM-NOT: f64x2
1309 ; SIMD128-NEXT: .functype compare_sext_uno_v2f64 (v128, v128) -> (v128){{$}}
1310 ; SIMD128-NEXT: f64x2.ne $push[[T0:[0-9]+]]=, $0, $0{{$}}
1311 ; SIMD128-NEXT: f64x2.ne $push[[T1:[0-9]+]]=, $1, $1{{$}}
1312 ; SIMD128-NEXT: v128.or $push[[R:[0-9]+]]=, $pop[[T0]], $pop[[T1]]{{$}}
1313 ; SIMD128-NEXT: return $pop[[R]]{{$}}
1314 define <2 x i64> @compare_sext_uno_v2f64 (<2 x double> %x, <2 x double> %y) {
1315   %cmp = fcmp uno <2 x double> %x, %y
1316   %res = sext <2 x i1> %cmp to <2 x i64>
1317   ret <2 x i64> %res
1318 }