test/CodeGen/AArch64/f16-instructions.ll

   1 ; RUN: llc < %s -mtriple aarch64-unknown-unknown -aarch64-neon-syntax=apple -asm-verbose=false | FileCheck %s
   2
   3 target datalayout = "e-m:o-i64:64-i128:128-n32:64-S128"
   4
   5 ; CHECK-LABEL: test_fadd:
   6 ; CHECK-NEXT: fcvt s1, h1
   7 ; CHECK-NEXT: fcvt s0, h0
   8 ; CHECK-NEXT: fadd s0, s0, s1
   9 ; CHECK-NEXT: fcvt h0, s0
  10 ; CHECK-NEXT: ret
  11 define half @test_fadd(half %a, half %b) #0 {
  12   %r = fadd half %a, %b
  13   ret half %r
  14 }
  15
  16 ; CHECK-LABEL: test_fsub:
  17 ; CHECK-NEXT: fcvt s1, h1
  18 ; CHECK-NEXT: fcvt s0, h0
  19 ; CHECK-NEXT: fsub s0, s0, s1
  20 ; CHECK-NEXT: fcvt h0, s0
  21 ; CHECK-NEXT: ret
  22 define half @test_fsub(half %a, half %b) #0 {
  23   %r = fsub half %a, %b
  24   ret half %r
  25 }
  26
  27 ; CHECK-LABEL: test_fmul:
  28 ; CHECK-NEXT: fcvt s1, h1
  29 ; CHECK-NEXT: fcvt s0, h0
  30 ; CHECK-NEXT: fmul s0, s0, s1
  31 ; CHECK-NEXT: fcvt h0, s0
  32 ; CHECK-NEXT: ret
  33 define half @test_fmul(half %a, half %b) #0 {
  34   %r = fmul half %a, %b
  35   ret half %r
  36 }
  37
  38 ; CHECK-LABEL: test_fdiv:
  39 ; CHECK-NEXT: fcvt s1, h1
  40 ; CHECK-NEXT: fcvt s0, h0
  41 ; CHECK-NEXT: fdiv s0, s0, s1
  42 ; CHECK-NEXT: fcvt h0, s0
  43 ; CHECK-NEXT: ret
  44 define half @test_fdiv(half %a, half %b) #0 {
  45   %r = fdiv half %a, %b
  46   ret half %r
  47 }
  48
  49 ; CHECK-LABEL: test_frem:
  50 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
  51 ; CHECK-NEXT: mov  x29, sp
  52 ; CHECK-NEXT: fcvt s0, h0
  53 ; CHECK-NEXT: fcvt s1, h1
  54 ; CHECK-NEXT: bl {{_?}}fmodf
  55 ; CHECK-NEXT: fcvt h0, s0
  56 ; CHECK-NEXT: ldp x29, x30, [sp], #16
  57 ; CHECK-NEXT: ret
  58 define half @test_frem(half %a, half %b) #0 {
  59   %r = frem half %a, %b
  60   ret half %r
  61 }
  62
  63 ; CHECK-LABEL: test_store:
  64 ; CHECK-NEXT: str  h0, [x0]
  65 ; CHECK-NEXT: ret
  66 define void @test_store(half %a, half* %b) #0 {
  67   store half %a, half* %b
  68   ret void
  69 }
  70
  71 ; CHECK-LABEL: test_load:
  72 ; CHECK-NEXT: ldr  h0, [x0]
  73 ; CHECK-NEXT: ret
  74 define half @test_load(half* %a) #0 {
  75   %r = load half, half* %a
  76   ret half %r
  77 }
  78
  79
  80 declare half @test_callee(half %a, half %b) #0
  81
  82 ; CHECK-LABEL: test_call:
  83 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
  84 ; CHECK-NEXT: mov  x29, sp
  85 ; CHECK-NEXT: bl {{_?}}test_callee
  86 ; CHECK-NEXT: ldp x29, x30, [sp], #16
  87 ; CHECK-NEXT: ret
  88 define half @test_call(half %a, half %b) #0 {
  89   %r = call half @test_callee(half %a, half %b)
  90   ret half %r
  91 }
  92
  93 ; CHECK-LABEL: test_call_flipped:
  94 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
  95 ; CHECK-NEXT: mov  x29, sp
  96 ; CHECK-NEXT: mov.16b  v2, v0
  97 ; CHECK-NEXT: mov.16b  v0, v1
  98 ; CHECK-NEXT: mov.16b  v1, v2
  99 ; CHECK-NEXT: bl {{_?}}test_callee
 100 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 101 ; CHECK-NEXT: ret
 102 define half @test_call_flipped(half %a, half %b) #0 {
 103   %r = call half @test_callee(half %b, half %a)
 104   ret half %r
 105 }
 106
 107 ; CHECK-LABEL: test_tailcall_flipped:
 108 ; CHECK-NEXT: mov.16b  v2, v0
 109 ; CHECK-NEXT: mov.16b  v0, v1
 110 ; CHECK-NEXT: mov.16b  v1, v2
 111 ; CHECK-NEXT: b {{_?}}test_callee
 112 define half @test_tailcall_flipped(half %a, half %b) #0 {
 113   %r = tail call half @test_callee(half %b, half %a)
 114   ret half %r
 115 }
 116
 117 ; CHECK-LABEL: test_select:
 118 ; CHECK-NEXT: fcvt s1, h1
 119 ; CHECK-NEXT: fcvt s0, h0
 120 ; CHECK-NEXT: cmp  w0, #0
 121 ; CHECK-NEXT: fcsel s0, s0, s1, ne
 122 ; CHECK-NEXT: fcvt h0, s0
 123 ; CHECK-NEXT: ret
 124 define half @test_select(half %a, half %b, i1 zeroext %c) #0 {
 125   %r = select i1 %c, half %a, half %b
 126   ret half %r
 127 }
 128
 129 ; CHECK-LABEL: test_select_cc:
 130 ; CHECK-DAG: fcvt s3, h3
 131 ; CHECK-DAG: fcvt s2, h2
 132 ; CHECK-DAG: fcvt s1, h1
 133 ; CHECK-DAG: fcvt s0, h0
 134 ; CHECK-DAG: fcmp s2, s3
 135 ; CHECK-DAG: cset [[CC:w[0-9]+]], ne
 136 ; CHECK-DAG: cmp [[CC]], #0
 137 ; CHECK-NEXT: fcsel s0, s0, s1, ne
 138 ; CHECK-NEXT: fcvt h0, s0
 139 ; CHECK-NEXT: ret
 140 define half @test_select_cc(half %a, half %b, half %c, half %d) #0 {
 141   %cc = fcmp une half %c, %d
 142   %r = select i1 %cc, half %a, half %b
 143   ret half %r
 144 }
 145
 146 ; CHECK-LABEL: test_fcmp_une:
 147 ; CHECK-NEXT: fcvt s1, h1
 148 ; CHECK-NEXT: fcvt s0, h0
 149 ; CHECK-NEXT: fcmp s0, s1
 150 ; CHECK-NEXT: cset  w0, ne
 151 ; CHECK-NEXT: ret
 152 define i1 @test_fcmp_une(half %a, half %b) #0 {
 153   %r = fcmp une half %a, %b
 154   ret i1 %r
 155 }
 156
 157 ; CHECK-LABEL: test_fcmp_ueq:
 158 ; CHECK-NEXT: fcvt s1, h1
 159 ; CHECK-NEXT: fcvt s0, h0
 160 ; CHECK-NEXT: fcmp s0, s1
 161 ; CHECK-NEXT: orr [[TRUE:w[0-9]+]], wzr, #0x1
 162 ; CHECK-NEXT: csel [[CC:w[0-9]+]], [[TRUE]], wzr, eq
 163 ; CHECK-NEXT: csel w0, [[TRUE]], [[CC]], vs
 164 ; CHECK-NEXT: ret
 165 define i1 @test_fcmp_ueq(half %a, half %b) #0 {
 166   %r = fcmp ueq half %a, %b
 167   ret i1 %r
 168 }
 169
 170 ; CHECK-LABEL: test_fcmp_ugt:
 171 ; CHECK-NEXT: fcvt s1, h1
 172 ; CHECK-NEXT: fcvt s0, h0
 173 ; CHECK-NEXT: fcmp s0, s1
 174 ; CHECK-NEXT: cset  w0, hi
 175 ; CHECK-NEXT: ret
 176 define i1 @test_fcmp_ugt(half %a, half %b) #0 {
 177   %r = fcmp ugt half %a, %b
 178   ret i1 %r
 179 }
 180
 181 ; CHECK-LABEL: test_fcmp_uge:
 182 ; CHECK-NEXT: fcvt s1, h1
 183 ; CHECK-NEXT: fcvt s0, h0
 184 ; CHECK-NEXT: fcmp s0, s1
 185 ; CHECK-NEXT: cset  w0, pl
 186 ; CHECK-NEXT: ret
 187 define i1 @test_fcmp_uge(half %a, half %b) #0 {
 188   %r = fcmp uge half %a, %b
 189   ret i1 %r
 190 }
 191
 192 ; CHECK-LABEL: test_fcmp_ult:
 193 ; CHECK-NEXT: fcvt s1, h1
 194 ; CHECK-NEXT: fcvt s0, h0
 195 ; CHECK-NEXT: fcmp s0, s1
 196 ; CHECK-NEXT: cset  w0, lt
 197 ; CHECK-NEXT: ret
 198 define i1 @test_fcmp_ult(half %a, half %b) #0 {
 199   %r = fcmp ult half %a, %b
 200   ret i1 %r
 201 }
 202
 203 ; CHECK-LABEL: test_fcmp_ule:
 204 ; CHECK-NEXT: fcvt s1, h1
 205 ; CHECK-NEXT: fcvt s0, h0
 206 ; CHECK-NEXT: fcmp s0, s1
 207 ; CHECK-NEXT: cset  w0, le
 208 ; CHECK-NEXT: ret
 209 define i1 @test_fcmp_ule(half %a, half %b) #0 {
 210   %r = fcmp ule half %a, %b
 211   ret i1 %r
 212 }
 213
 214
 215 ; CHECK-LABEL: test_fcmp_uno:
 216 ; CHECK-NEXT: fcvt s1, h1
 217 ; CHECK-NEXT: fcvt s0, h0
 218 ; CHECK-NEXT: fcmp s0, s1
 219 ; CHECK-NEXT: cset  w0, vs
 220 ; CHECK-NEXT: ret
 221 define i1 @test_fcmp_uno(half %a, half %b) #0 {
 222   %r = fcmp uno half %a, %b
 223   ret i1 %r
 224 }
 225
 226 ; CHECK-LABEL: test_fcmp_one:
 227 ; CHECK-NEXT: fcvt s1, h1
 228 ; CHECK-NEXT: fcvt s0, h0
 229 ; CHECK-NEXT: fcmp s0, s1
 230 ; CHECK-NEXT: orr [[TRUE:w[0-9]+]], wzr, #0x1
 231 ; CHECK-NEXT: csel [[CC:w[0-9]+]], [[TRUE]], wzr, mi
 232 ; CHECK-NEXT: csel w0, [[TRUE]], [[CC]], gt
 233 ; CHECK-NEXT: ret
 234 define i1 @test_fcmp_one(half %a, half %b) #0 {
 235   %r = fcmp one half %a, %b
 236   ret i1 %r
 237 }
 238
 239 ; CHECK-LABEL: test_fcmp_oeq:
 240 ; CHECK-NEXT: fcvt s1, h1
 241 ; CHECK-NEXT: fcvt s0, h0
 242 ; CHECK-NEXT: fcmp s0, s1
 243 ; CHECK-NEXT: cset  w0, eq
 244 ; CHECK-NEXT: ret
 245 define i1 @test_fcmp_oeq(half %a, half %b) #0 {
 246   %r = fcmp oeq half %a, %b
 247   ret i1 %r
 248 }
 249
 250 ; CHECK-LABEL: test_fcmp_ogt:
 251 ; CHECK-NEXT: fcvt s1, h1
 252 ; CHECK-NEXT: fcvt s0, h0
 253 ; CHECK-NEXT: fcmp s0, s1
 254 ; CHECK-NEXT: cset  w0, gt
 255 ; CHECK-NEXT: ret
 256 define i1 @test_fcmp_ogt(half %a, half %b) #0 {
 257   %r = fcmp ogt half %a, %b
 258   ret i1 %r
 259 }
 260
 261 ; CHECK-LABEL: test_fcmp_oge:
 262 ; CHECK-NEXT: fcvt s1, h1
 263 ; CHECK-NEXT: fcvt s0, h0
 264 ; CHECK-NEXT: fcmp s0, s1
 265 ; CHECK-NEXT: cset  w0, ge
 266 ; CHECK-NEXT: ret
 267 define i1 @test_fcmp_oge(half %a, half %b) #0 {
 268   %r = fcmp oge half %a, %b
 269   ret i1 %r
 270 }
 271
 272 ; CHECK-LABEL: test_fcmp_olt:
 273 ; CHECK-NEXT: fcvt s1, h1
 274 ; CHECK-NEXT: fcvt s0, h0
 275 ; CHECK-NEXT: fcmp s0, s1
 276 ; CHECK-NEXT: cset  w0, mi
 277 ; CHECK-NEXT: ret
 278 define i1 @test_fcmp_olt(half %a, half %b) #0 {
 279   %r = fcmp olt half %a, %b
 280   ret i1 %r
 281 }
 282
 283 ; CHECK-LABEL: test_fcmp_ole:
 284 ; CHECK-NEXT: fcvt s1, h1
 285 ; CHECK-NEXT: fcvt s0, h0
 286 ; CHECK-NEXT: fcmp s0, s1
 287 ; CHECK-NEXT: cset  w0, ls
 288 ; CHECK-NEXT: ret
 289 define i1 @test_fcmp_ole(half %a, half %b) #0 {
 290   %r = fcmp ole half %a, %b
 291   ret i1 %r
 292 }
 293
 294 ; CHECK-LABEL: test_fcmp_ord:
 295 ; CHECK-NEXT: fcvt s1, h1
 296 ; CHECK-NEXT: fcvt s0, h0
 297 ; CHECK-NEXT: fcmp s0, s1
 298 ; CHECK-NEXT: cset  w0, vc
 299 ; CHECK-NEXT: ret
 300 define i1 @test_fcmp_ord(half %a, half %b) #0 {
 301   %r = fcmp ord half %a, %b
 302   ret i1 %r
 303 }
 304
 305 ; CHECK-LABEL: test_br_cc:
 306 ; CHECK-NEXT: fcvt s1, h1
 307 ; CHECK-NEXT: fcvt s0, h0
 308 ; CHECK-NEXT: fcmp s0, s1
 309 ; CHECK-NEXT: b.mi [[BRCC_ELSE:.?LBB[0-9_]+]]
 310 ; CHECK-NEXT: str  wzr, [x0]
 311 ; CHECK-NEXT: ret
 312 ; CHECK-NEXT: [[BRCC_ELSE]]:
 313 ; CHECK-NEXT: str  wzr, [x1]
 314 ; CHECK-NEXT: ret
 315 define void @test_br_cc(half %a, half %b, i32* %p1, i32* %p2) #0 {
 316   %c = fcmp uge half %a, %b
 317   br i1 %c, label %then, label %else
 318 then:
 319   store i32 0, i32* %p1
 320   ret void
 321 else:
 322   store i32 0, i32* %p2
 323   ret void
 324 }
 325
 326 ; CHECK-LABEL: test_phi:
 327 ; CHECK: mov  x[[PTR:[0-9]+]], x0
 328 ; CHECK: ldr  h[[AB:[0-9]+]], [x[[PTR]]]
 329 ; CHECK: [[LOOP:LBB[0-9_]+]]:
 330 ; CHECK: mov.16b  v[[R:[0-9]+]], v[[AB]]
 331 ; CHECK: ldr  h[[AB]], [x[[PTR]]]
 332 ; CHECK: mov  x0, x[[PTR]]
 333 ; CHECK: bl {{_?}}test_dummy
 334 ; CHECK: mov.16b  v0, v[[R]]
 335 ; CHECK: ret
 336 define half @test_phi(half* %p1) #0 {
 337 entry:
 338   %a = load half, half* %p1
 339   br label %loop
 340 loop:
 341   %r = phi half [%a, %entry], [%b, %loop]
 342   %b = load half, half* %p1
 343   %c = call i1 @test_dummy(half* %p1)
 344   br i1 %c, label %loop, label %return
 345 return:
 346   ret half %r
 347 }
 348 declare i1 @test_dummy(half* %p1) #0
 349
 350 ; CHECK-LABEL: test_fptosi_i32:
 351 ; CHECK-NEXT: fcvt s0, h0
 352 ; CHECK-NEXT: fcvtzs w0, s0
 353 ; CHECK-NEXT: ret
 354 define i32 @test_fptosi_i32(half %a) #0 {
 355   %r = fptosi half %a to i32
 356   ret i32 %r
 357 }
 358
 359 ; CHECK-LABEL: test_fptosi_i64:
 360 ; CHECK-NEXT: fcvt s0, h0
 361 ; CHECK-NEXT: fcvtzs x0, s0
 362 ; CHECK-NEXT: ret
 363 define i64 @test_fptosi_i64(half %a) #0 {
 364   %r = fptosi half %a to i64
 365   ret i64 %r
 366 }
 367
 368 ; CHECK-LABEL: test_fptoui_i32:
 369 ; CHECK-NEXT: fcvt s0, h0
 370 ; CHECK-NEXT: fcvtzu w0, s0
 371 ; CHECK-NEXT: ret
 372 define i32 @test_fptoui_i32(half %a) #0 {
 373   %r = fptoui half %a to i32
 374   ret i32 %r
 375 }
 376
 377 ; CHECK-LABEL: test_fptoui_i64:
 378 ; CHECK-NEXT: fcvt s0, h0
 379 ; CHECK-NEXT: fcvtzu x0, s0
 380 ; CHECK-NEXT: ret
 381 define i64 @test_fptoui_i64(half %a) #0 {
 382   %r = fptoui half %a to i64
 383   ret i64 %r
 384 }
 385
 386 ; CHECK-LABEL: test_uitofp_i32:
 387 ; CHECK-NEXT: ucvtf s0, w0
 388 ; CHECK-NEXT: fcvt h0, s0
 389 ; CHECK-NEXT: ret
 390 define half @test_uitofp_i32(i32 %a) #0 {
 391   %r = uitofp i32 %a to half
 392   ret half %r
 393 }
 394
 395 ; CHECK-LABEL: test_uitofp_i64:
 396 ; CHECK-NEXT: ucvtf s0, x0
 397 ; CHECK-NEXT: fcvt h0, s0
 398 ; CHECK-NEXT: ret
 399 define half @test_uitofp_i64(i64 %a) #0 {
 400   %r = uitofp i64 %a to half
 401   ret half %r
 402 }
 403
 404 ; CHECK-LABEL: test_sitofp_i32:
 405 ; CHECK-NEXT: scvtf s0, w0
 406 ; CHECK-NEXT: fcvt h0, s0
 407 ; CHECK-NEXT: ret
 408 define half @test_sitofp_i32(i32 %a) #0 {
 409   %r = sitofp i32 %a to half
 410   ret half %r
 411 }
 412
 413 ; CHECK-LABEL: test_sitofp_i64:
 414 ; CHECK-NEXT: scvtf s0, x0
 415 ; CHECK-NEXT: fcvt h0, s0
 416 ; CHECK-NEXT: ret
 417 define half @test_sitofp_i64(i64 %a) #0 {
 418   %r = sitofp i64 %a to half
 419   ret half %r
 420 }
 421
 422 ; CHECK-LABEL: test_fptrunc_float:
 423 ; CHECK-NEXT: fcvt h0, s0
 424 ; CHECK-NEXT: ret
 425
 426 define half @test_fptrunc_float(float %a) #0 {
 427   %r = fptrunc float %a to half
 428   ret half %r
 429 }
 430
 431 ; CHECK-LABEL: test_fptrunc_double:
 432 ; CHECK-NEXT: fcvt h0, d0
 433 ; CHECK-NEXT: ret
 434 define half @test_fptrunc_double(double %a) #0 {
 435   %r = fptrunc double %a to half
 436   ret half %r
 437 }
 438
 439 ; CHECK-LABEL: test_fpext_float:
 440 ; CHECK-NEXT: fcvt s0, h0
 441 ; CHECK-NEXT: ret
 442 define float @test_fpext_float(half %a) #0 {
 443   %r = fpext half %a to float
 444   ret float %r
 445 }
 446
 447 ; CHECK-LABEL: test_fpext_double:
 448 ; CHECK-NEXT: fcvt d0, h0
 449 ; CHECK-NEXT: ret
 450 define double @test_fpext_double(half %a) #0 {
 451   %r = fpext half %a to double
 452   ret double %r
 453 }
 454
 455
 456 ; CHECK-LABEL: test_bitcast_halftoi16:
 457 ; CHECK-NEXT: fmov w0, s0
 458 ; CHECK-NEXT: ret
 459 define i16 @test_bitcast_halftoi16(half %a) #0 {
 460   %r = bitcast half %a to i16
 461   ret i16 %r
 462 }
 463
 464 ; CHECK-LABEL: test_bitcast_i16tohalf:
 465 ; CHECK-NEXT: fmov s0, w0
 466 ; CHECK-NEXT: ret
 467 define half @test_bitcast_i16tohalf(i16 %a) #0 {
 468   %r = bitcast i16 %a to half
 469   ret half %r
 470 }
 471
 472
 473 declare half @llvm.sqrt.f16(half %a) #0
 474 declare half @llvm.powi.f16(half %a, i32 %b) #0
 475 declare half @llvm.sin.f16(half %a) #0
 476 declare half @llvm.cos.f16(half %a) #0
 477 declare half @llvm.pow.f16(half %a, half %b) #0
 478 declare half @llvm.exp.f16(half %a) #0
 479 declare half @llvm.exp2.f16(half %a) #0
 480 declare half @llvm.log.f16(half %a) #0
 481 declare half @llvm.log10.f16(half %a) #0
 482 declare half @llvm.log2.f16(half %a) #0
 483 declare half @llvm.fma.f16(half %a, half %b, half %c) #0
 484 declare half @llvm.fabs.f16(half %a) #0
 485 declare half @llvm.minnum.f16(half %a, half %b) #0
 486 declare half @llvm.maxnum.f16(half %a, half %b) #0
 487 declare half @llvm.copysign.f16(half %a, half %b) #0
 488 declare half @llvm.floor.f16(half %a) #0
 489 declare half @llvm.ceil.f16(half %a) #0
 490 declare half @llvm.trunc.f16(half %a) #0
 491 declare half @llvm.rint.f16(half %a) #0
 492 declare half @llvm.nearbyint.f16(half %a) #0
 493 declare half @llvm.round.f16(half %a) #0
 494 declare half @llvm.fmuladd.f16(half %a, half %b, half %c) #0
 495
 496 ; CHECK-LABEL: test_sqrt:
 497 ; CHECK-NEXT: fcvt s0, h0
 498 ; CHECK-NEXT: fsqrt s0, s0
 499 ; CHECK-NEXT: fcvt h0, s0
 500 ; CHECK-NEXT: ret
 501 define half @test_sqrt(half %a) #0 {
 502   %r = call half @llvm.sqrt.f16(half %a)
 503   ret half %r
 504 }
 505
 506 ; CHECK-LABEL: test_powi:
 507 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
 508 ; CHECK-NEXT: mov  x29, sp
 509 ; CHECK-NEXT: fcvt s0, h0
 510 ; CHECK-NEXT: bl {{_?}}__powisf2
 511 ; CHECK-NEXT: fcvt h0, s0
 512 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 513 ; CHECK-NEXT: ret
 514 define half @test_powi(half %a, i32 %b) #0 {
 515   %r = call half @llvm.powi.f16(half %a, i32 %b)
 516   ret half %r
 517 }
 518
 519 ; CHECK-LABEL: test_sin:
 520 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
 521 ; CHECK-NEXT: mov  x29, sp
 522 ; CHECK-NEXT: fcvt s0, h0
 523 ; CHECK-NEXT: bl {{_?}}sinf
 524 ; CHECK-NEXT: fcvt h0, s0
 525 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 526 ; CHECK-NEXT: ret
 527 define half @test_sin(half %a) #0 {
 528   %r = call half @llvm.sin.f16(half %a)
 529   ret half %r
 530 }
 531
 532 ; CHECK-LABEL: test_cos:
 533 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
 534 ; CHECK-NEXT: mov  x29, sp
 535 ; CHECK-NEXT: fcvt s0, h0
 536 ; CHECK-NEXT: bl {{_?}}cosf
 537 ; CHECK-NEXT: fcvt h0, s0
 538 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 539 ; CHECK-NEXT: ret
 540 define half @test_cos(half %a) #0 {
 541   %r = call half @llvm.cos.f16(half %a)
 542   ret half %r
 543 }
 544
 545 ; CHECK-LABEL: test_pow:
 546 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
 547 ; CHECK-NEXT: mov  x29, sp
 548 ; CHECK-NEXT: fcvt s0, h0
 549 ; CHECK-NEXT: fcvt s1, h1
 550 ; CHECK-NEXT: bl {{_?}}powf
 551 ; CHECK-NEXT: fcvt h0, s0
 552 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 553 ; CHECK-NEXT: ret
 554 define half @test_pow(half %a, half %b) #0 {
 555   %r = call half @llvm.pow.f16(half %a, half %b)
 556   ret half %r
 557 }
 558
 559 ; CHECK-LABEL: test_exp:
 560 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
 561 ; CHECK-NEXT: mov  x29, sp
 562 ; CHECK-NEXT: fcvt s0, h0
 563 ; CHECK-NEXT: bl {{_?}}expf
 564 ; CHECK-NEXT: fcvt h0, s0
 565 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 566 ; CHECK-NEXT: ret
 567 define half @test_exp(half %a) #0 {
 568   %r = call half @llvm.exp.f16(half %a)
 569   ret half %r
 570 }
 571
 572 ; CHECK-LABEL: test_exp2:
 573 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
 574 ; CHECK-NEXT: mov  x29, sp
 575 ; CHECK-NEXT: fcvt s0, h0
 576 ; CHECK-NEXT: bl {{_?}}exp2f
 577 ; CHECK-NEXT: fcvt h0, s0
 578 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 579 ; CHECK-NEXT: ret
 580 define half @test_exp2(half %a) #0 {
 581   %r = call half @llvm.exp2.f16(half %a)
 582   ret half %r
 583 }
 584
 585 ; CHECK-LABEL: test_log:
 586 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
 587 ; CHECK-NEXT: mov  x29, sp
 588 ; CHECK-NEXT: fcvt s0, h0
 589 ; CHECK-NEXT: bl {{_?}}logf
 590 ; CHECK-NEXT: fcvt h0, s0
 591 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 592 ; CHECK-NEXT: ret
 593 define half @test_log(half %a) #0 {
 594   %r = call half @llvm.log.f16(half %a)
 595   ret half %r
 596 }
 597
 598 ; CHECK-LABEL: test_log10:
 599 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
 600 ; CHECK-NEXT: mov  x29, sp
 601 ; CHECK-NEXT: fcvt s0, h0
 602 ; CHECK-NEXT: bl {{_?}}log10f
 603 ; CHECK-NEXT: fcvt h0, s0
 604 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 605 ; CHECK-NEXT: ret
 606 define half @test_log10(half %a) #0 {
 607   %r = call half @llvm.log10.f16(half %a)
 608   ret half %r
 609 }
 610
 611 ; CHECK-LABEL: test_log2:
 612 ; CHECK-NEXT: stp x29, x30, [sp, #-16]!
 613 ; CHECK-NEXT: mov  x29, sp
 614 ; CHECK-NEXT: fcvt s0, h0
 615 ; CHECK-NEXT: bl {{_?}}log2f
 616 ; CHECK-NEXT: fcvt h0, s0
 617 ; CHECK-NEXT: ldp x29, x30, [sp], #16
 618 ; CHECK-NEXT: ret
 619 define half @test_log2(half %a) #0 {
 620   %r = call half @llvm.log2.f16(half %a)
 621   ret half %r
 622 }
 623
 624 ; CHECK-LABEL: test_fma:
 625 ; CHECK-NEXT: fcvt s2, h2
 626 ; CHECK-NEXT: fcvt s1, h1
 627 ; CHECK-NEXT: fcvt s0, h0
 628 ; CHECK-NEXT: fmadd s0, s0, s1, s2
 629 ; CHECK-NEXT: fcvt h0, s0
 630 ; CHECK-NEXT: ret
 631 define half @test_fma(half %a, half %b, half %c) #0 {
 632   %r = call half @llvm.fma.f16(half %a, half %b, half %c)
 633   ret half %r
 634 }
 635
 636 ; CHECK-LABEL: test_fabs:
 637 ; CHECK-NEXT: fcvt s0, h0
 638 ; CHECK-NEXT: fabs s0, s0
 639 ; CHECK-NEXT: fcvt h0, s0
 640 ; CHECK-NEXT: ret
 641 define half @test_fabs(half %a) #0 {
 642   %r = call half @llvm.fabs.f16(half %a)
 643   ret half %r
 644 }
 645
 646 ; CHECK-LABEL: test_minnum:
 647 ; CHECK-NEXT: fcvt s1, h1
 648 ; CHECK-NEXT: fcvt s0, h0
 649 ; CHECK-NEXT: fminnm s0, s0, s1
 650 ; CHECK-NEXT: fcvt h0, s0
 651 ; CHECK-NEXT: ret
 652 define half @test_minnum(half %a, half %b) #0 {
 653   %r = call half @llvm.minnum.f16(half %a, half %b)
 654   ret half %r
 655 }
 656
 657 ; CHECK-LABEL: test_maxnum:
 658 ; CHECK-NEXT: fcvt s1, h1
 659 ; CHECK-NEXT: fcvt s0, h0
 660 ; CHECK-NEXT: fmaxnm s0, s0, s1
 661 ; CHECK-NEXT: fcvt h0, s0
 662 ; CHECK-NEXT: ret
 663 define half @test_maxnum(half %a, half %b) #0 {
 664   %r = call half @llvm.maxnum.f16(half %a, half %b)
 665   ret half %r
 666 }
 667
 668 ; CHECK-LABEL: test_copysign:
 669 ; CHECK-NEXT: sub sp, sp, #16
 670 ; CHECK-NEXT: str h1, [sp, #8]
 671 ; CHECK-NEXT: ldr x8, [sp, #8]
 672 ; CHECK-NEXT: fcvt s0, h0
 673 ; CHECK-NEXT: fabs s0, s0
 674 ; CHECK-NEXT: fneg s1, s0
 675 ; CHECK-NEXT: lsl x8, x8, #48
 676 ; CHECK-NEXT: cmp  x8, #0
 677 ; CHECK-NEXT: fcsel s0, s1, s0, lt
 678 ; CHECK-NEXT: fcvt h0, s0
 679 ; CHECK-NEXT: add sp, sp, #16
 680 ; CHECK-NEXT: ret
 681 define half @test_copysign(half %a, half %b) #0 {
 682   %r = call half @llvm.copysign.f16(half %a, half %b)
 683   ret half %r
 684 }
 685
 686 ; CHECK-LABEL: test_copysign_f32:
 687 ; CHECK-NEXT: fcvt s0, h0
 688 ; CHECK-NEXT: movi.4s v2, #0x80, lsl #24
 689 ; CHECK-NEXT: bit.16b v0, v1, v2
 690 ; CHECK-NEXT: fcvt h0, s0
 691 ; CHECK-NEXT: ret
 692 define half @test_copysign_f32(half %a, float %b) #0 {
 693   %tb = fptrunc float %b to half
 694   %r = call half @llvm.copysign.f16(half %a, half %tb)
 695   ret half %r
 696 }
 697
 698 ; CHECK-LABEL: test_copysign_f64:
 699 ; CHECK-NEXT: fcvt s1, d1
 700 ; CHECK-NEXT: fcvt s0, h0
 701 ; CHECK-NEXT: movi.4s v2, #0x80, lsl #24
 702 ; CHECK-NEXT: bit.16b v0, v1, v2
 703 ; CHECK-NEXT: fcvt h0, s0
 704 ; CHECK-NEXT: ret
 705 define half @test_copysign_f64(half %a, double %b) #0 {
 706   %tb = fptrunc double %b to half
 707   %r = call half @llvm.copysign.f16(half %a, half %tb)
 708   ret half %r
 709 }
 710
 711 ; CHECK-LABEL: test_floor:
 712 ; CHECK-NEXT: fcvt [[FLOAT32:s[0-9]+]], h0
 713 ; CHECK-NEXT: frintm [[INT32:s[0-9]+]], [[FLOAT32]]
 714 ; CHECK-NEXT: fcvt h0, [[INT32]]
 715 ; CHECK-NEXT: ret
 716 define half @test_floor(half %a) #0 {
 717   %r = call half @llvm.floor.f16(half %a)
 718   ret half %r
 719 }
 720
 721 ; CHECK-LABEL: test_ceil:
 722 ; CHECK-NEXT: fcvt [[FLOAT32:s[0-9]+]], h0
 723 ; CHECK-NEXT: frintp [[INT32:s[0-9]+]], [[FLOAT32]]
 724 ; CHECK-NEXT: fcvt h0, [[INT32]]
 725 ; CHECK-NEXT: ret
 726 define half @test_ceil(half %a) #0 {
 727   %r = call half @llvm.ceil.f16(half %a)
 728   ret half %r
 729 }
 730
 731 ; CHECK-LABEL: test_trunc:
 732 ; CHECK-NEXT: fcvt [[FLOAT32:s[0-9]+]], h0
 733 ; CHECK-NEXT: frintz [[INT32:s[0-9]+]], [[FLOAT32]]
 734 ; CHECK-NEXT: fcvt h0, [[INT32]]
 735 ; CHECK-NEXT: ret
 736 define half @test_trunc(half %a) #0 {
 737   %r = call half @llvm.trunc.f16(half %a)
 738   ret half %r
 739 }
 740
 741 ; CHECK-LABEL: test_rint:
 742 ; CHECK-NEXT: fcvt s0, h0
 743 ; CHECK-NEXT: frintx s0, s0
 744 ; CHECK-NEXT: fcvt h0, s0
 745 ; CHECK-NEXT: ret
 746 define half @test_rint(half %a) #0 {
 747   %r = call half @llvm.rint.f16(half %a)
 748   ret half %r
 749 }
 750
 751 ; CHECK-LABEL: test_nearbyint:
 752 ; CHECK-NEXT: fcvt s0, h0
 753 ; CHECK-NEXT: frinti s0, s0
 754 ; CHECK-NEXT: fcvt h0, s0
 755 ; CHECK-NEXT: ret
 756 define half @test_nearbyint(half %a) #0 {
 757   %r = call half @llvm.nearbyint.f16(half %a)
 758   ret half %r
 759 }
 760
 761 ; CHECK-LABEL: test_round:
 762 ; CHECK-NEXT: fcvt [[FLOAT32:s[0-9]+]], h0
 763 ; CHECK-NEXT: frinta [[INT32:s[0-9]+]], [[FLOAT32]]
 764 ; CHECK-NEXT: fcvt h0, [[INT32]]
 765 ; CHECK-NEXT: ret
 766 define half @test_round(half %a) #0 {
 767   %r = call half @llvm.round.f16(half %a)
 768   ret half %r
 769 }
 770
 771 ; CHECK-LABEL: test_fmuladd:
 772 ; CHECK-NEXT: fcvt s1, h1
 773 ; CHECK-NEXT: fcvt s0, h0
 774 ; CHECK-NEXT: fmul s0, s0, s1
 775 ; CHECK-NEXT: fcvt h0, s0
 776 ; CHECK-NEXT: fcvt s0, h0
 777 ; CHECK-NEXT: fcvt s1, h2
 778 ; CHECK-NEXT: fadd s0, s0, s1
 779 ; CHECK-NEXT: fcvt h0, s0
 780 ; CHECK-NEXT: ret
 781 define half @test_fmuladd(half %a, half %b, half %c) #0 {
 782   %r = call half @llvm.fmuladd.f16(half %a, half %b, half %c)
 783   ret half %r
 784 }
 785
 786 attributes #0 = { nounwind }