test/CodeGen/AArch64/fp16-v4-instructions.ll

   1 ; RUN: llc < %s -asm-verbose=false -mtriple=aarch64-none-eabi -mattr=-fullfp16 | FileCheck %s --check-prefix=CHECK-CVT --check-prefix=CHECK-COMMON
   2 ; RUN: llc < %s -asm-verbose=false -mtriple=aarch64-none-eabi -mattr=+fullfp16 | FileCheck %s --check-prefix=CHECK-FP16 --check-prefix=CHECK-COMMON
   3
   4 define <4 x half> @add_h(<4 x half> %a, <4 x half> %b) {
   5 entry:
   6 ; CHECK-CVT-LABEL: add_h:
   7 ; CHECK-CVT-DAG:   fcvtl [[OP1:v[0-9]+\.4s]], v0.4h
   8 ; CHECK-CVT-DAG:   fcvtl [[OP2:v[0-9]+\.4s]], v1.4h
   9 ; CHECK-CVT-NEXT:  fadd [[RES:v[0-9]+.4s]], [[OP1]], [[OP2]]
  10 ; CHECK-CVT-NEXT:  fcvtn v0.4h, [[RES]]
  11
  12 ; CHECK-FP16-LABEL: add_h:
  13 ; CHECK-FP16:       fadd  v0.4h, v0.4h, v1.4h
  14 ; CHECK-FP16-NEXT:  ret
  15   %0 = fadd <4 x half> %a, %b
  16   ret <4 x half> %0
  17 }
  18
  19
  20 define <4 x half> @build_h4(<4 x half> %a) {
  21 entry:
  22 ; CHECK-COMMON-LABEL: build_h4:
  23 ; CHECK-COMMON:       mov [[GPR:w[0-9]+]], #15565
  24 ; CHECK-COMMON-NEXT:  dup v0.4h, [[GPR]]
  25   ret <4 x half> <half 0xH3CCD, half 0xH3CCD, half 0xH3CCD, half 0xH3CCD>
  26 }
  27
  28
  29 define <4 x half> @sub_h(<4 x half> %a, <4 x half> %b) {
  30 entry:
  31 ; CHECK-CVT-LABEL: sub_h:
  32 ; CHECK-CVT-DAG:   fcvtl [[OP1:v[0-9]+\.4s]], v0.4h
  33 ; CHECK-CVT-DAG:   fcvtl [[OP2:v[0-9]+\.4s]], v1.4h
  34 ; CHECK-CVT-NEXT:  fsub [[RES:v[0-9]+.4s]], [[OP1]], [[OP2]]
  35 ; CHECK-CVT-NEXT:  fcvtn v0.4h, [[RES]]
  36
  37 ; CHECK-FP16-LABEL: sub_h:
  38 ; CHECK-FP16:       fsub  v0.4h, v0.4h, v1.4h
  39 ; CHECK-FP16-NEXT:  ret
  40   %0 = fsub <4 x half> %a, %b
  41   ret <4 x half> %0
  42 }
  43
  44
  45 define <4 x half> @mul_h(<4 x half> %a, <4 x half> %b) {
  46 entry:
  47 ; CHECK-CVT-LABEL: mul_h:
  48 ; CHECK-CVT-DAG:   fcvtl [[OP1:v[0-9]+\.4s]], v0.4h
  49 ; CHECK-CVT-DAG:   fcvtl [[OP2:v[0-9]+\.4s]], v1.4h
  50 ; CHECK-CVT-NEXT:  fmul [[RES:v[0-9]+.4s]], [[OP1]], [[OP2]]
  51 ; CHECK-CVT-NEXT:  fcvtn v0.4h, [[RES]]
  52
  53 ; CHECK-FP16-LABEL: mul_h:
  54 ; CHECK-FP16:       fmul  v0.4h, v0.4h, v1.4h
  55 ; CHECK-FP16-NEXT:  ret
  56   %0 = fmul <4 x half> %a, %b
  57   ret <4 x half> %0
  58 }
  59
  60
  61 define <4 x half> @div_h(<4 x half> %a, <4 x half> %b) {
  62 entry:
  63 ; CHECK-CVT-LABEL: div_h:
  64 ; CHECK-CVT-DAG:   fcvtl [[OP1:v[0-9]+\.4s]], v0.4h
  65 ; CHECK-CVT-DAG:   fcvtl [[OP2:v[0-9]+\.4s]], v1.4h
  66 ; CHECK-CVT-NEXT:  fdiv [[RES:v[0-9]+.4s]], [[OP1]], [[OP2]]
  67 ; CHECK-CVT-NEXT:  fcvtn v0.4h, [[RES]]
  68
  69 ; CHECK-FP16-LABEL: div_h:
  70 ; CHECK-FP16:       fdiv  v0.4h, v0.4h, v1.4h
  71 ; CHECK-FP16-NEXT:  ret
  72   %0 = fdiv <4 x half> %a, %b
  73   ret <4 x half> %0
  74 }
  75
  76
  77 define <4 x half> @load_h(<4 x half>* %a) {
  78 entry:
  79 ; CHECK-COMMON-LABEL: load_h:
  80 ; CHECK-COMMON:       ldr d0, [x0]
  81 ; CHECK-COMMON-NEXT:  ret
  82   %0 = load <4 x half>, <4 x half>* %a, align 4
  83   ret <4 x half> %0
  84 }
  85
  86
  87 define void @store_h(<4 x half>* %a, <4 x half> %b) {
  88 entry:
  89 ; CHECK-COMMON-LABEL: store_h:
  90 ; CHECK-COMMON:       str d0, [x0]
  91 ; CHECK-COMMON-NEXT:  ret
  92   store <4 x half> %b, <4 x half>* %a, align 4
  93   ret void
  94 }
  95
  96 define <4 x half> @s_to_h(<4 x float> %a) {
  97 ; CHECK-COMMON-LABEL: s_to_h:
  98 ; CHECK-COMMON:       fcvtn v0.4h, v0.4s
  99 ; CHECK-COMMON-NEXT:  ret
 100   %1 = fptrunc <4 x float> %a to <4 x half>
 101   ret <4 x half> %1
 102 }
 103
 104 define <4 x half> @d_to_h(<4 x double> %a) {
 105 ; CHECK-LABEL: d_to_h:
 106 ; CHECK-DAG: fcvt h
 107 ; CHECK-DAG: fcvt h
 108 ; CHECK-DAG: fcvt h
 109 ; CHECK-DAG: fcvt h
 110 ; CHECK-DAG: mov v{{[0-9]+}}.h
 111 ; CHECK-DAG: mov v{{[0-9]+}}.h
 112 ; CHECK-DAG: mov v{{[0-9]+}}.h
 113 ; CHECK-DAG: mov v{{[0-9]+}}.h
 114   %1 = fptrunc <4 x double> %a to <4 x half>
 115   ret <4 x half> %1
 116 }
 117
 118 define <4 x float> @h_to_s(<4 x half> %a) {
 119 ; CHECK-COMMON-LABEL: h_to_s:
 120 ; CHECK-COMMON:       fcvtl v0.4s, v0.4h
 121 ; CHECK-COMMON-NEXT:  ret
 122   %1 = fpext <4 x half> %a to <4 x float>
 123   ret <4 x float> %1
 124 }
 125
 126 define <4 x double> @h_to_d(<4 x half> %a) {
 127 ; CHECK-LABEL: h_to_d:
 128 ; CHECK-DAG: mov h{{[0-9]+}}, v0.h
 129 ; CHECK-DAG: mov h{{[0-9]+}}, v0.h
 130 ; CHECK-DAG: mov h{{[0-9]+}}, v0.h
 131 ; CHECK-DAG: fcvt
 132 ; CHECK-DAG: fcvt
 133 ; CHECK-DAG: fcvt
 134 ; CHECK-DAG: fcvt
 135   %1 = fpext <4 x half> %a to <4 x double>
 136   ret <4 x double> %1
 137 }
 138
 139 define <4 x half> @bitcast_i_to_h(float, <4 x i16> %a) {
 140 ; CHECK-COMMON-LABEL: bitcast_i_to_h:
 141 ; CHECK-COMMON:       mov v0.16b, v1.16b
 142 ; CHECK-COMMON-NEXT:  ret
 143   %2 = bitcast <4 x i16> %a to <4 x half>
 144   ret <4 x half> %2
 145 }
 146
 147 define <4 x i16> @bitcast_h_to_i(float, <4 x half> %a) {
 148 ; CHECK-COMMON-LABEL: bitcast_h_to_i:
 149 ; CHECK-COMMON:       mov v0.16b, v1.16b
 150 ; CHECK-COMMON-NEXT:  ret
 151   %2 = bitcast <4 x half> %a to <4 x i16>
 152   ret <4 x i16> %2
 153 }
 154
 155 define <4 x half> @sitofp_i8(<4 x i8> %a) #0 {
 156 ; CHECK-COMMON-LABEL: sitofp_i8:
 157 ; CHECK-COMMON-NEXT:  shl [[OP1:v[0-9]+\.4h]], v0.4h, #8
 158 ; CHECK-COMMON-NEXT:  sshr [[OP2:v[0-9]+\.4h]], [[OP1]], #8
 159 ; CHECK-COMMON-NEXT:  sshll [[OP3:v[0-9]+\.4s]], [[OP2]], #0
 160 ; CHECK-COMMON-NEXT:  scvtf [[OP4:v[0-9]+\.4s]], [[OP3]]
 161 ; CHECK-COMMON-NEXT:  fcvtn v0.4h, [[OP4]]
 162 ; CHECK-COMMON-NEXT:  ret
 163   %1 = sitofp <4 x i8> %a to <4 x half>
 164   ret <4 x half> %1
 165 }
 166
 167
 168 define <4 x half> @sitofp_i16(<4 x i16> %a) #0 {
 169 ; CHECK-COMMON-LABEL: sitofp_i16:
 170 ; CHECK-COMMON-NEXT:  sshll [[OP1:v[0-9]+\.4s]], v0.4h, #0
 171 ; CHECK-COMMON-NEXT:  scvtf [[OP2:v[0-9]+\.4s]], [[OP1]]
 172 ; CHECK-COMMON-NEXT:  fcvtn v0.4h, [[OP2]]
 173 ; CHECK-COMMON-NEXT:  ret
 174   %1 = sitofp <4 x i16> %a to <4 x half>
 175   ret <4 x half> %1
 176 }
 177
 178
 179 define <4 x half> @sitofp_i32(<4 x i32> %a) #0 {
 180 ; CHECK-COMMON-LABEL: sitofp_i32:
 181 ; CHECK-COMMON-NEXT:  scvtf [[OP1:v[0-9]+\.4s]], v0.4s
 182 ; CHECK-COMMON-NEXT:  fcvtn v0.4h, [[OP1]]
 183 ; CHECK-COMMON-NEXT:  ret
 184   %1 = sitofp <4 x i32> %a to <4 x half>
 185   ret <4 x half> %1
 186 }
 187
 188
 189 define <4 x half> @sitofp_i64(<4 x i64> %a) #0 {
 190 ; CHECK-COMMON-LABEL: sitofp_i64:
 191 ; CHECK-COMMON-DAG:   scvtf [[OP1:v[0-9]+\.2d]], v0.2d
 192 ; CHECK-COMMON-DAG:   scvtf [[OP2:v[0-9]+\.2d]], v1.2d
 193 ; CHECK-COMMON-DAG:   fcvtn [[OP3:v[0-9]+]].2s, [[OP1]]
 194 ; CHECK-COMMON-NEXT:  fcvtn2 [[OP3]].4s, [[OP2]]
 195 ; CHECK-COMMON-NEXT:  fcvtn v0.4h, [[OP3]].4s
 196 ; CHECK-COMMON-NEXT:  ret
 197   %1 = sitofp <4 x i64> %a to <4 x half>
 198   ret <4 x half> %1
 199 }
 200
 201 define <4 x half> @uitofp_i8(<4 x i8> %a) #0 {
 202 ; CHECK-COMMON-LABEL: uitofp_i8:
 203 ; CHECK-COMMON-NEXT:  bic v0.4h, #255, lsl #8
 204 ; CHECK-COMMON-NEXT:  ushll [[OP1:v[0-9]+\.4s]], v0.4h, #0
 205 ; CHECK-COMMON-NEXT:  ucvtf [[OP2:v[0-9]+\.4s]], [[OP1]]
 206 ; CHECK-COMMON-NEXT:  fcvtn v0.4h, [[OP2]]
 207 ; CHECK-COMMON-NEXT:  ret
 208   %1 = uitofp <4 x i8> %a to <4 x half>
 209   ret <4 x half> %1
 210 }
 211
 212
 213 define <4 x half> @uitofp_i16(<4 x i16> %a) #0 {
 214 ; CHECK-COMMON-LABEL: uitofp_i16:
 215 ; CHECK-COMMON-NEXT:  ushll [[OP1:v[0-9]+\.4s]], v0.4h, #0
 216 ; CHECK-COMMON-NEXT:  ucvtf [[OP2:v[0-9]+\.4s]], [[OP1]]
 217 ; CHECK-COMMON-NEXT:  fcvtn v0.4h, [[OP2]]
 218 ; CHECK-COMMON-NEXT:  ret
 219   %1 = uitofp <4 x i16> %a to <4 x half>
 220   ret <4 x half> %1
 221 }
 222
 223
 224 define <4 x half> @uitofp_i32(<4 x i32> %a) #0 {
 225 ; CHECK-COMMON-LABEL: uitofp_i32:
 226 ; CHECK-COMMON-NEXT:  ucvtf [[OP1:v[0-9]+\.4s]], v0.4s
 227 ; CHECK-COMMON-NEXT:  fcvtn v0.4h, [[OP1]]
 228 ; CHECK-COMMON-NEXT:  ret
 229   %1 = uitofp <4 x i32> %a to <4 x half>
 230   ret <4 x half> %1
 231 }
 232
 233
 234 define <4 x half> @uitofp_i64(<4 x i64> %a) #0 {
 235 ; CHECK-COMMON-LABEL: uitofp_i64:
 236 ; CHECK-COMMON-DAG:   ucvtf [[OP1:v[0-9]+\.2d]], v0.2d
 237 ; CHECK-COMMON-DAG:   ucvtf [[OP2:v[0-9]+\.2d]], v1.2d
 238 ; CHECK-COMMON-DAG:   fcvtn [[OP3:v[0-9]+]].2s, [[OP1]]
 239 ; CHECK-COMMON-NEXT:  fcvtn2 [[OP3]].4s, [[OP2]]
 240 ; CHECK-COMMON-NEXT:  fcvtn v0.4h, [[OP3]].4s
 241 ; CHECK-COMMON-NEXT:  ret
 242   %1 = uitofp <4 x i64> %a to <4 x half>
 243   ret <4 x half> %1
 244 }
 245
 246 define void @test_insert_at_zero(half %a, <4 x half>* %b) #0 {
 247 ; CHECK-COMMON-LABEL: test_insert_at_zero:
 248 ; CHECK-COMMON-NEXT:  str d0, [x0]
 249 ; CHECK-COMMON-NEXT:  ret
 250   %1 = insertelement <4 x half> undef, half %a, i64 0
 251   store <4 x half> %1, <4 x half>* %b, align 4
 252   ret void
 253 }
 254
 255 define <4 x i8> @fptosi_i8(<4 x half> %a) #0 {
 256 ; CHECK-COMMON-LABEL: fptosi_i8:
 257 ; CHECK-COMMON-NEXT:  fcvtl  [[REG1:v[0-9]+\.4s]], v0.4h
 258 ; CHECK-COMMON-NEXT:  fcvtzs [[REG2:v[0-9]+\.4s]], [[REG1]]
 259 ; CHECK-COMMON-NEXT:  xtn    v0.4h, [[REG2]]
 260 ; CHECK-COMMON-NEXT:  ret
 261   %1 = fptosi<4 x half> %a to <4 x i8>
 262   ret <4 x i8> %1
 263 }
 264
 265 define <4 x i16> @fptosi_i16(<4 x half> %a) #0 {
 266 ; CHECK-COMMON-LABEL: fptosi_i16:
 267 ; CHECK-COMMON-NEXT:  fcvtl  [[REG1:v[0-9]+\.4s]], v0.4h
 268 ; CHECK-COMMON-NEXT:  fcvtzs [[REG2:v[0-9]+\.4s]], [[REG1]]
 269 ; CHECK-COMMON-NEXT:  xtn    v0.4h, [[REG2]]
 270 ; CHECK-COMMON-NEXT:  ret
 271   %1 = fptosi<4 x half> %a to <4 x i16>
 272   ret <4 x i16> %1
 273 }
 274
 275 define <4 x i8> @fptoui_i8(<4 x half> %a) #0 {
 276 ; CHECK-COMMON-LABEL: fptoui_i8:
 277 ; CHECK-COMMON-NEXT:  fcvtl  [[REG1:v[0-9]+\.4s]], v0.4h
 278 ; NOTE: fcvtzs selected here because the xtn shaves the sign bit
 279 ; CHECK-COMMON-NEXT:  fcvtzs [[REG2:v[0-9]+\.4s]], [[REG1]]
 280 ; CHECK-COMMON-NEXT:  xtn    v0.4h, [[REG2]]
 281 ; CHECK-COMMON-NEXT:  ret
 282   %1 = fptoui<4 x half> %a to <4 x i8>
 283   ret <4 x i8> %1
 284 }
 285
 286 define <4 x i16> @fptoui_i16(<4 x half> %a) #0 {
 287 ; CHECK-COMMON-LABEL: fptoui_i16:
 288 ; CHECK-COMMON-NEXT:  fcvtl  [[REG1:v[0-9]+\.4s]], v0.4h
 289 ; CHECK-COMMON-NEXT:  fcvtzu [[REG2:v[0-9]+\.4s]], [[REG1]]
 290 ; CHECK-COMMON-NEXT:  xtn    v0.4h, [[REG2]]
 291 ; CHECK-COMMON-NEXT:  ret
 292   %1 = fptoui<4 x half> %a to <4 x i16>
 293   ret <4 x i16> %1
 294 }
 295
 296 define <4 x i1> @test_fcmp_une(<4 x half> %a, <4 x half> %b) #0 {
 297 ; CHECK-CVT-LABEL: test_fcmp_une:
 298 ; CHECK-CVT: fcvtl
 299 ; CHECK-CVT: fcvtl
 300 ; CHECK-CVT: fcmeq
 301 ; CHECK-CVT: mvn
 302 ; CHECK-CVT: xtn
 303 ; CHECK-CVT: ret
 304
 305 ; CHECK-FP16-LABEL: test_fcmp_une:
 306 ; CHECK-FP16-NOT:   fcvt
 307 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 308 ; CHECK-FP16:       csetm {{.*}}, ne
 309 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 310 ; CHECK-FP16:       csetm {{.*}}, ne
 311 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 312 ; CHECK-FP16:       csetm {{.*}}, ne
 313 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 314 ; CHECK-FP16:       csetm {{.*}}, ne
 315 ; CHECK-FP16:       ret
 316   %1 = fcmp une <4 x half> %a, %b
 317   ret <4 x i1> %1
 318 }
 319
 320 define <4 x i1> @test_fcmp_ueq(<4 x half> %a, <4 x half> %b) #0 {
 321 ; CHECK-CVT-LABEL: test_fcmp_ueq:
 322 ; CHECK-CVT: fcvtl
 323 ; CHECK-CVT: fcvtl
 324 ; CHECK-CVT: fcmgt
 325 ; CHECK-CVT: fcmgt
 326 ; CHECK-CVT: orr
 327 ; CHECK-CVT: xtn
 328 ; CHECK-CVT: mvn
 329 ; CHECK-CVT: ret
 330
 331 ; CHECK-FP16-LABEL: test_fcmp_ueq:
 332 ; CHECK-FP16-NOT:   fcvt
 333 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 334 ; CHECK-FP16:       csetm {{.*}}, eq
 335 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 336 ; CHECK-FP16:       csetm {{.*}}, eq
 337 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 338 ; CHECK-FP16:       csetm {{.*}}, eq
 339 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 340 ; CHECK-FP16:       csetm {{.*}}, eq
 341 ; CHECK-FP16:       ret
 342   %1 = fcmp ueq <4 x half> %a, %b
 343   ret <4 x i1> %1
 344 }
 345
 346 define <4 x i1> @test_fcmp_ugt(<4 x half> %a, <4 x half> %b) #0 {
 347 ; CHECK-CVT-LABEL: test_fcmp_ugt:
 348 ; CHECK-CVT: fcvtl
 349 ; CHECK-CVT: fcvtl
 350 ; CHECK-CVT: fcmge
 351 ; CHECK-CVT: xtn
 352 ; CHECK-CVT: mvn
 353 ; CHECK-CVT: ret
 354
 355 ; CHECK-FP16-LABEL: test_fcmp_ugt:
 356 ; CHECK-FP16-NOT:   fcvt
 357 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 358 ; CHECK-FP16:       csetm {{.*}}, hi
 359 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 360 ; CHECK-FP16:       csetm {{.*}}, hi
 361 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 362 ; CHECK-FP16:       csetm {{.*}}, hi
 363 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 364 ; CHECK-FP16:       csetm {{.*}}, hi
 365 ; CHECK-FP16:       ret
 366   %1 = fcmp ugt <4 x half> %a, %b
 367   ret <4 x i1> %1
 368 }
 369
 370 define <4 x i1> @test_fcmp_uge(<4 x half> %a, <4 x half> %b) #0 {
 371 ; CHECK-CVT-LABEL: test_fcmp_uge:
 372 ; CHECK-CVT: fcvtl
 373 ; CHECK-CVT: fcvtl
 374 ; CHECK-CVT: fcmgt
 375 ; CHECK-CVT: xtn
 376 ; CHECK-CVT: mvn
 377 ; CHECK-CVT: ret
 378
 379 ; CHECK-FP16-LABEL: test_fcmp_uge:
 380 ; CHECK-FP16-NOT:   fcvt
 381 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 382 ; CHECK-FP16:       csetm {{.*}}, pl
 383 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 384 ; CHECK-FP16:       csetm {{.*}}, pl
 385 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 386 ; CHECK-FP16:       csetm {{.*}}, pl
 387 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 388 ; CHECK-FP16:       csetm {{.*}}, pl
 389 ; CHECK-FP16:       ret
 390   %1 = fcmp uge <4 x half> %a, %b
 391   ret <4 x i1> %1
 392 }
 393
 394 define <4 x i1> @test_fcmp_ult(<4 x half> %a, <4 x half> %b) #0 {
 395 ; CHECK-CVT-LABEL: test_fcmp_ult:
 396 ; CHECK-CVT: fcvtl
 397 ; CHECK-CVT: fcvtl
 398 ; CHECK-CVT: fcmge
 399 ; CHECK-CVT: xtn
 400 ; CHECK-CVT: mvn
 401 ; CHECK-CVT: ret
 402
 403 ; CHECK-FP16-LABEL: test_fcmp_ult:
 404 ; CHECK-FP16-NOT:   fcvt
 405 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 406 ; CHECK-FP16:       csetm {{.*}}, lt
 407 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 408 ; CHECK-FP16:       csetm {{.*}}, lt
 409 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 410 ; CHECK-FP16:       csetm {{.*}}, lt
 411 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 412 ; CHECK-FP16:       csetm {{.*}}, lt
 413 ; CHECK-FP16:       ret
 414   %1 = fcmp ult <4 x half> %a, %b
 415   ret <4 x i1> %1
 416 }
 417
 418 define <4 x i1> @test_fcmp_ule(<4 x half> %a, <4 x half> %b) #0 {
 419 ; CHECK-CVT-LABEL: test_fcmp_ule:
 420 ; CHECK-CVT: fcvtl
 421 ; CHECK-CVT: fcvtl
 422 ; CHECK-CVT: fcmgt
 423 ; CHECK-CVT: xtn
 424 ; CHECK-CVT: mvn
 425 ; CHECK-CVT: ret
 426
 427 ; CHECK-FP16-LABEL: test_fcmp_ule:
 428 ; CHECK-FP16-NOT:   fcvt
 429 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 430 ; CHECK-FP16:       csetm {{.*}}, le
 431 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 432 ; CHECK-FP16:       csetm {{.*}}, le
 433 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 434 ; CHECK-FP16:       csetm {{.*}}, le
 435 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 436 ; CHECK-FP16:       csetm {{.*}}, le
 437 ; CHECK-FP16:       ret
 438   %1 = fcmp ule <4 x half> %a, %b
 439   ret <4 x i1> %1
 440 }
 441
 442 define <4 x i1> @test_fcmp_uno(<4 x half> %a, <4 x half> %b) #0 {
 443 ; CHECK-CVT-LABEL: test_fcmp_uno:
 444 ; CHECK-CVT: fcvtl
 445 ; CHECK-CVT: fcvtl
 446 ; CHECK-CVT: fcmge
 447 ; CHECK-CVT: fcmgt
 448 ; CHECK-CVT: orr
 449 ; CHECK-CVT: xtn
 450 ; CHECK-CVT: mvn
 451 ; CHECK-CVT: ret
 452
 453 ; CHECK-FP16-LABEL: test_fcmp_uno:
 454 ; CHECK-FP16-NOT:   fcvt
 455 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 456 ; CHECK-FP16:       csetm {{.*}}, vs
 457 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 458 ; CHECK-FP16:       csetm {{.*}}, vs
 459 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 460 ; CHECK-FP16:       csetm {{.*}}, vs
 461 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 462 ; CHECK-FP16:       csetm {{.*}}, vs
 463 ; CHECK-FP16:       ret
 464   %1 = fcmp uno <4 x half> %a, %b
 465   ret <4 x i1> %1
 466 }
 467
 468 define <4 x i1> @test_fcmp_one(<4 x half> %a, <4 x half> %b) #0 {
 469 ; CHECK-CVT-LABEL: test_fcmp_one:
 470 ; CHECK-CVT: fcvtl
 471 ; CHECK-CVT: fcvtl
 472 ; CHECK-CVT: fcmgt
 473 ; CHECK-CVT: fcmgt
 474 ; CHECK-CVT: orr
 475 ; CHECK-CVT: xtn
 476 ; CHECK-CVT: ret
 477
 478 ; CHECK-FP16-LABEL: test_fcmp_one:
 479 ; CHECK-FP16-NOT:   fcvt
 480 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 481 ; CHECK-FP16:       csetm {{.*}}, mi
 482 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 483 ; CHECK-FP16:       csetm {{.*}}, mi
 484 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 485 ; CHECK-FP16:       csetm {{.*}}, mi
 486 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 487 ; CHECK-FP16:       csetm {{.*}}, mi
 488 ; CHECK-FP16:       ret
 489   %1 = fcmp one <4 x half> %a, %b
 490   ret <4 x i1> %1
 491 }
 492
 493 define <4 x i1> @test_fcmp_oeq(<4 x half> %a, <4 x half> %b) #0 {
 494 ; CHECK-CVT-LABEL: test_fcmp_oeq:
 495 ; CHECK-CVT: fcvtl
 496 ; CHECK-CVT: fcvtl
 497 ; CHECK-CVT: fcmeq
 498 ; CHECK-CVT: xtn
 499 ; CHECK-CVT: ret
 500
 501 ; CHECK-FP16-LABEL: test_fcmp_oeq:
 502 ; CHECK-FP16-NOT:   fcvt
 503 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 504 ; CHECK-FP16:       csetm {{.*}}, eq
 505 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 506 ; CHECK-FP16:       csetm {{.*}}, eq
 507 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 508 ; CHECK-FP16:       csetm {{.*}}, eq
 509 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 510 ; CHECK-FP16:       csetm {{.*}}, eq
 511 ; CHECK-FP16:       ret
 512   %1 = fcmp oeq <4 x half> %a, %b
 513   ret <4 x i1> %1
 514 }
 515
 516 define <4 x i1> @test_fcmp_ogt(<4 x half> %a, <4 x half> %b) #0 {
 517 ; CHECK-CVT-LABEL: test_fcmp_ogt:
 518 ; CHECK-CVT: fcvtl
 519 ; CHECK-CVT: fcvtl
 520 ; CHECK-CVT: fcmgt
 521 ; CHECK-CVT: xtn
 522 ; CHECK-CVT: ret
 523
 524 ; CHECK-FP16-LABEL: test_fcmp_ogt:
 525 ; CHECK-FP16-NOT:   fcvt
 526 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 527 ; CHECK-FP16:       csetm {{.*}}, gt
 528 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 529 ; CHECK-FP16:       csetm {{.*}}, gt
 530 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 531 ; CHECK-FP16:       csetm {{.*}}, gt
 532 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 533 ; CHECK-FP16:       csetm {{.*}}, gt
 534 ; CHECK-FP16:       ret
 535   %1 = fcmp ogt <4 x half> %a, %b
 536   ret <4 x i1> %1
 537 }
 538
 539 define <4 x i1> @test_fcmp_oge(<4 x half> %a, <4 x half> %b) #0 {
 540 ; CHECK-CVT-LABEL: test_fcmp_oge:
 541 ; CHECK-CVT: fcvtl
 542 ; CHECK-CVT: fcvtl
 543 ; CHECK-CVT: fcmge
 544 ; CHECK-CVT: xtn
 545 ; CHECK-CVT: ret
 546
 547 ; CHECK-FP16-LABEL: test_fcmp_oge:
 548 ; CHECK-FP16-NOT:   fcvt
 549 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 550 ; CHECK-FP16:       csetm {{.*}}, ge
 551 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 552 ; CHECK-FP16:       csetm {{.*}}, ge
 553 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 554 ; CHECK-FP16:       csetm {{.*}}, ge
 555 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 556 ; CHECK-FP16:       csetm {{.*}}, ge
 557 ; CHECK-FP16:       ret
 558   %1 = fcmp oge <4 x half> %a, %b
 559   ret <4 x i1> %1
 560 }
 561
 562 define <4 x i1> @test_fcmp_olt(<4 x half> %a, <4 x half> %b) #0 {
 563 ; CHECK-CVT-LABEL: test_fcmp_olt:
 564 ; CHECK-CVT: fcvtl
 565 ; CHECK-CVT: fcvtl
 566 ; CHECK-CVT: fcmgt
 567 ; CHECK-CVT: xtn
 568 ; CHECK-CVT: ret
 569
 570 ; CHECK-FP16-LABEL: test_fcmp_olt:
 571 ; CHECK-FP16-NOT:   fcvt
 572 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 573 ; CHECK-FP16:       csetm {{.*}}, mi
 574 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 575 ; CHECK-FP16:       csetm {{.*}}, mi
 576 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 577 ; CHECK-FP16:       csetm {{.*}}, mi
 578 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 579 ; CHECK-FP16:       csetm {{.*}}, mi
 580 ; CHECK-FP16:       ret
 581   %1 = fcmp olt <4 x half> %a, %b
 582   ret <4 x i1> %1
 583 }
 584
 585 define <4 x i1> @test_fcmp_ole(<4 x half> %a, <4 x half> %b) #0 {
 586 ; CHECK-CVT-LABEL: test_fcmp_ole:
 587 ; CHECK-CVT: fcvtl
 588 ; CHECK-CVT: fcvtl
 589 ; CHECK-CVT: fcmge
 590 ; CHECK-CVT: xtn
 591 ; CHECK-CVT: ret
 592
 593 ; CHECK-FP16-LABEL: test_fcmp_ole:
 594 ; CHECK-FP16-NOT:   fcvt
 595 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 596 ; CHECK-FP16:       csetm {{.*}}, ls
 597 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 598 ; CHECK-FP16:       csetm {{.*}}, ls
 599 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 600 ; CHECK-FP16:       csetm {{.*}}, ls
 601 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 602 ; CHECK-FP16:       csetm {{.*}}, ls
 603 ; CHECK-FP16:       ret
 604   %1 = fcmp ole <4 x half> %a, %b
 605   ret <4 x i1> %1
 606 }
 607
 608 define <4 x i1> @test_fcmp_ord(<4 x half> %a, <4 x half> %b) #0 {
 609 ; CHECK-CVT-LABEL: test_fcmp_ord:
 610 ; CHECK-CVT: fcvtl
 611 ; CHECK-CVT: fcvtl
 612 ; CHECK-CVT: fcmge
 613 ; CHECK-CVT: fcmgt
 614 ; CHECK-CVT: orr
 615 ; CHECK-CVT: xtn
 616 ; CHECK-CVT: ret
 617
 618 ; CHECK-FP16-LABEL: test_fcmp_ord:
 619 ; CHECK-FP16-NOT:   fcvt
 620 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 621 ; CHECK-FP16:       csetm {{.*}}, vc
 622 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 623 ; CHECK-FP16:       csetm {{.*}}, vc
 624 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 625 ; CHECK-FP16:       csetm {{.*}}, vc
 626 ; CHECK-FP16:       fcmp  h{{.}}, h{{.}}
 627 ; CHECK-FP16:       csetm {{.*}}, vc
 628 ; CHECK-FP16:       ret
 629   %1 = fcmp ord <4 x half> %a, %b
 630   ret <4 x i1> %1
 631 }
 632
 633 attributes #0 = { nounwind }