llvm/test/CodeGen/RISCV/GlobalISel/fp128.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=riscv64 -global-isel < %s \
   3 ; RUN:   | FileCheck -check-prefixes=CHECK,RV64I %s
   4 ; RUN: llc -mtriple=riscv64 -global-isel -mattr=+d < %s \
   5 ; RUN:   | FileCheck -check-prefixes=CHECK,RV64D %s
   6
   7 ; FIXME: Support RV32.
   8
   9 define fp128 @fadd(fp128 %x, fp128 %y) nounwind {
  10 ; CHECK-LABEL: fadd:
  11 ; CHECK:       # %bb.0:
  12 ; CHECK-NEXT:    addi sp, sp, -16
  13 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  14 ; CHECK-NEXT:    call __addtf3
  15 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  16 ; CHECK-NEXT:    addi sp, sp, 16
  17 ; CHECK-NEXT:    ret
  18  %a = fadd fp128 %x, %y
  19   ret fp128 %a
  20 }
  21
  22 define fp128 @fsub(fp128 %x, fp128 %y) nounwind {
  23 ; CHECK-LABEL: fsub:
  24 ; CHECK:       # %bb.0:
  25 ; CHECK-NEXT:    addi sp, sp, -16
  26 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  27 ; CHECK-NEXT:    call __subtf3
  28 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  29 ; CHECK-NEXT:    addi sp, sp, 16
  30 ; CHECK-NEXT:    ret
  31   %a = fsub fp128 %x, %y
  32   ret fp128 %a
  33 }
  34
  35 define fp128 @fmul(fp128 %x, fp128 %y) nounwind {
  36 ; CHECK-LABEL: fmul:
  37 ; CHECK:       # %bb.0:
  38 ; CHECK-NEXT:    addi sp, sp, -16
  39 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  40 ; CHECK-NEXT:    call __multf3
  41 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  42 ; CHECK-NEXT:    addi sp, sp, 16
  43 ; CHECK-NEXT:    ret
  44   %a = fmul fp128 %x, %y
  45   ret fp128 %a
  46 }
  47
  48 define fp128 @fdiv(fp128 %x, fp128 %y) nounwind {
  49 ; CHECK-LABEL: fdiv:
  50 ; CHECK:       # %bb.0:
  51 ; CHECK-NEXT:    addi sp, sp, -16
  52 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  53 ; CHECK-NEXT:    call __divtf3
  54 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  55 ; CHECK-NEXT:    addi sp, sp, 16
  56 ; CHECK-NEXT:    ret
  57   %a = fdiv fp128 %x, %y
  58   ret fp128 %a
  59 }
  60
  61 define fp128 @frem(fp128 %x, fp128 %y) nounwind {
  62 ; CHECK-LABEL: frem:
  63 ; CHECK:       # %bb.0:
  64 ; CHECK-NEXT:    addi sp, sp, -16
  65 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  66 ; CHECK-NEXT:    call fmodl
  67 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  68 ; CHECK-NEXT:    addi sp, sp, 16
  69 ; CHECK-NEXT:    ret
  70   %a = frem fp128 %x, %y
  71   ret fp128 %a
  72 }
  73
  74 define fp128 @fma(fp128 %x, fp128 %y, fp128 %z) nounwind {
  75 ; CHECK-LABEL: fma:
  76 ; CHECK:       # %bb.0:
  77 ; CHECK-NEXT:    addi sp, sp, -16
  78 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  79 ; CHECK-NEXT:    call fmal
  80 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  81 ; CHECK-NEXT:    addi sp, sp, 16
  82 ; CHECK-NEXT:    ret
  83   %a = call fp128 @llvm.fma.f128(fp128 %x, fp128 %y, fp128 %z)
  84   ret fp128 %a
  85 }
  86
  87 define fp128 @fneg(fp128 %x) {
  88 ; CHECK-LABEL: fneg:
  89 ; CHECK:       # %bb.0:
  90 ; CHECK-NEXT:    li a2, -1
  91 ; CHECK-NEXT:    slli a2, a2, 63
  92 ; CHECK-NEXT:    xor a1, a1, a2
  93 ; CHECK-NEXT:    ret
  94   %a = fneg fp128 %x
  95   ret fp128 %a
  96 }
  97
  98 define fp128 @fabs(fp128 %x) {
  99 ; CHECK-LABEL: fabs:
 100 ; CHECK:       # %bb.0:
 101 ; CHECK-NEXT:    slli a1, a1, 1
 102 ; CHECK-NEXT:    srli a1, a1, 1
 103 ; CHECK-NEXT:    ret
 104   %a = call fp128 @llvm.fabs.f128(fp128 %x)
 105   ret fp128 %a
 106 }
 107
 108 define fp128 @fcopysign(fp128 %x, fp128 %y) {
 109 ; CHECK-LABEL: fcopysign:
 110 ; CHECK:       # %bb.0:
 111 ; CHECK-NEXT:    slli a1, a1, 1
 112 ; CHECK-NEXT:    srli a3, a3, 63
 113 ; CHECK-NEXT:    srli a1, a1, 1
 114 ; CHECK-NEXT:    slli a3, a3, 63
 115 ; CHECK-NEXT:    or a1, a1, a3
 116 ; CHECK-NEXT:    ret
 117   %a = call fp128 @llvm.copysign.f128(fp128 %x, fp128 %y)
 118   ret fp128 %a
 119 }
 120
 121 define i1 @fcmp(fp128 %x, fp128 %y) nounwind {
 122 ; CHECK-LABEL: fcmp:
 123 ; CHECK:       # %bb.0:
 124 ; CHECK-NEXT:    addi sp, sp, -16
 125 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 126 ; CHECK-NEXT:    call __eqtf2
 127 ; CHECK-NEXT:    sext.w a0, a0
 128 ; CHECK-NEXT:    seqz a0, a0
 129 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 130 ; CHECK-NEXT:    addi sp, sp, 16
 131 ; CHECK-NEXT:    ret
 132   %a = fcmp oeq fp128 %x, %y
 133   ret i1 %a
 134 }
 135
 136 define fp128 @constant(fp128 %x) nounwind {
 137 ; CHECK-LABEL: constant:
 138 ; CHECK:       # %bb.0:
 139 ; CHECK-NEXT:    addi sp, sp, -16
 140 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 141 ; CHECK-NEXT:    lui a2, %hi(.LCPI10_0)
 142 ; CHECK-NEXT:    addi a3, a2, %lo(.LCPI10_0)
 143 ; CHECK-NEXT:    ld a2, 0(a3)
 144 ; CHECK-NEXT:    ld a3, 8(a3)
 145 ; CHECK-NEXT:    call __addtf3
 146 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 147 ; CHECK-NEXT:    addi sp, sp, 16
 148 ; CHECK-NEXT:    ret
 149   %a = fadd fp128 %x, 0xL00000000000000007FFF000000000000
 150   ret fp128 %a
 151 }
 152
 153 define fp128 @fpext_f32(float %x, float %y) nounwind {
 154 ; RV64I-LABEL: fpext_f32:
 155 ; RV64I:       # %bb.0:
 156 ; RV64I-NEXT:    addi sp, sp, -16
 157 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 158 ; RV64I-NEXT:    call __addsf3
 159 ; RV64I-NEXT:    call __extendsftf2
 160 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 161 ; RV64I-NEXT:    addi sp, sp, 16
 162 ; RV64I-NEXT:    ret
 163 ;
 164 ; RV64D-LABEL: fpext_f32:
 165 ; RV64D:       # %bb.0:
 166 ; RV64D-NEXT:    addi sp, sp, -16
 167 ; RV64D-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 168 ; RV64D-NEXT:    fadd.s fa0, fa0, fa1
 169 ; RV64D-NEXT:    call __extendsftf2
 170 ; RV64D-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 171 ; RV64D-NEXT:    addi sp, sp, 16
 172 ; RV64D-NEXT:    ret
 173   %a = fadd float %x, %y
 174   %b = fpext float %a to fp128
 175   ret fp128 %b
 176 }
 177
 178 define fp128 @fpext_f64(double %x, double %y) nounwind {
 179 ; RV64I-LABEL: fpext_f64:
 180 ; RV64I:       # %bb.0:
 181 ; RV64I-NEXT:    addi sp, sp, -16
 182 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 183 ; RV64I-NEXT:    call __adddf3
 184 ; RV64I-NEXT:    call __extenddftf2
 185 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 186 ; RV64I-NEXT:    addi sp, sp, 16
 187 ; RV64I-NEXT:    ret
 188 ;
 189 ; RV64D-LABEL: fpext_f64:
 190 ; RV64D:       # %bb.0:
 191 ; RV64D-NEXT:    addi sp, sp, -16
 192 ; RV64D-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 193 ; RV64D-NEXT:    fadd.d fa0, fa0, fa1
 194 ; RV64D-NEXT:    call __extenddftf2
 195 ; RV64D-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 196 ; RV64D-NEXT:    addi sp, sp, 16
 197 ; RV64D-NEXT:    ret
 198   %a = fadd double %x, %y
 199   %b = fpext double %a to fp128
 200   ret fp128 %b
 201 }
 202
 203 define float @fptrunc_f32(fp128 %x, float %y) nounwind {
 204 ; RV64I-LABEL: fptrunc_f32:
 205 ; RV64I:       # %bb.0:
 206 ; RV64I-NEXT:    addi sp, sp, -16
 207 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 208 ; RV64I-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
 209 ; RV64I-NEXT:    mv s0, a2
 210 ; RV64I-NEXT:    call __trunctfsf2
 211 ; RV64I-NEXT:    mv a1, s0
 212 ; RV64I-NEXT:    call __addsf3
 213 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 214 ; RV64I-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
 215 ; RV64I-NEXT:    addi sp, sp, 16
 216 ; RV64I-NEXT:    ret
 217 ;
 218 ; RV64D-LABEL: fptrunc_f32:
 219 ; RV64D:       # %bb.0:
 220 ; RV64D-NEXT:    addi sp, sp, -16
 221 ; RV64D-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 222 ; RV64D-NEXT:    fsd fs0, 0(sp) # 8-byte Folded Spill
 223 ; RV64D-NEXT:    fmv.s fs0, fa0
 224 ; RV64D-NEXT:    call __trunctfsf2
 225 ; RV64D-NEXT:    fadd.s fa0, fa0, fs0
 226 ; RV64D-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 227 ; RV64D-NEXT:    fld fs0, 0(sp) # 8-byte Folded Reload
 228 ; RV64D-NEXT:    addi sp, sp, 16
 229 ; RV64D-NEXT:    ret
 230   %a = fptrunc fp128 %x to float
 231   %b = fadd float %a, %y
 232   ret float %b
 233 }
 234
 235 define double @fptrunc_f64(fp128 %x, double %y) nounwind {
 236 ; RV64I-LABEL: fptrunc_f64:
 237 ; RV64I:       # %bb.0:
 238 ; RV64I-NEXT:    addi sp, sp, -16
 239 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 240 ; RV64I-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
 241 ; RV64I-NEXT:    mv s0, a2
 242 ; RV64I-NEXT:    call __trunctfdf2
 243 ; RV64I-NEXT:    mv a1, s0
 244 ; RV64I-NEXT:    call __adddf3
 245 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 246 ; RV64I-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
 247 ; RV64I-NEXT:    addi sp, sp, 16
 248 ; RV64I-NEXT:    ret
 249 ;
 250 ; RV64D-LABEL: fptrunc_f64:
 251 ; RV64D:       # %bb.0:
 252 ; RV64D-NEXT:    addi sp, sp, -16
 253 ; RV64D-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 254 ; RV64D-NEXT:    fsd fs0, 0(sp) # 8-byte Folded Spill
 255 ; RV64D-NEXT:    fmv.d fs0, fa0
 256 ; RV64D-NEXT:    call __trunctfdf2
 257 ; RV64D-NEXT:    fadd.d fa0, fa0, fs0
 258 ; RV64D-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 259 ; RV64D-NEXT:    fld fs0, 0(sp) # 8-byte Folded Reload
 260 ; RV64D-NEXT:    addi sp, sp, 16
 261 ; RV64D-NEXT:    ret
 262   %a = fptrunc fp128 %x to double
 263   %b = fadd double %a, %y
 264   ret double %b
 265 }
 266
 267 define i8 @fptosi_i8(fp128 %x) nounwind {
 268 ; CHECK-LABEL: fptosi_i8:
 269 ; CHECK:       # %bb.0:
 270 ; CHECK-NEXT:    addi sp, sp, -16
 271 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 272 ; CHECK-NEXT:    call __fixtfsi
 273 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 274 ; CHECK-NEXT:    addi sp, sp, 16
 275 ; CHECK-NEXT:    ret
 276   %a = fptosi fp128 %x to i8
 277   ret i8 %a
 278 }
 279
 280 define i16 @fptosi_i16(fp128 %x) nounwind {
 281 ; CHECK-LABEL: fptosi_i16:
 282 ; CHECK:       # %bb.0:
 283 ; CHECK-NEXT:    addi sp, sp, -16
 284 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 285 ; CHECK-NEXT:    call __fixtfsi
 286 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 287 ; CHECK-NEXT:    addi sp, sp, 16
 288 ; CHECK-NEXT:    ret
 289   %a = fptosi fp128 %x to i16
 290   ret i16 %a
 291 }
 292
 293 define i32 @fptosi_i32(fp128 %x) nounwind {
 294 ; CHECK-LABEL: fptosi_i32:
 295 ; CHECK:       # %bb.0:
 296 ; CHECK-NEXT:    addi sp, sp, -16
 297 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 298 ; CHECK-NEXT:    call __fixtfsi
 299 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 300 ; CHECK-NEXT:    addi sp, sp, 16
 301 ; CHECK-NEXT:    ret
 302   %a = fptosi fp128 %x to i32
 303   ret i32 %a
 304 }
 305
 306 define i64 @fptosi_i64(fp128 %x) nounwind {
 307 ; CHECK-LABEL: fptosi_i64:
 308 ; CHECK:       # %bb.0:
 309 ; CHECK-NEXT:    addi sp, sp, -16
 310 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 311 ; CHECK-NEXT:    call __fixtfdi
 312 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 313 ; CHECK-NEXT:    addi sp, sp, 16
 314 ; CHECK-NEXT:    ret
 315   %a = fptosi fp128 %x to i64
 316   ret i64 %a
 317 }
 318
 319 define i128 @fptosi_i128(fp128 %x) nounwind {
 320 ; CHECK-LABEL: fptosi_i128:
 321 ; CHECK:       # %bb.0:
 322 ; CHECK-NEXT:    addi sp, sp, -16
 323 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 324 ; CHECK-NEXT:    call __fixtfti
 325 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 326 ; CHECK-NEXT:    addi sp, sp, 16
 327 ; CHECK-NEXT:    ret
 328   %a = fptosi fp128 %x to i128
 329   ret i128 %a
 330 }
 331
 332 define i8 @fptoui_i8(fp128 %x) nounwind {
 333 ; CHECK-LABEL: fptoui_i8:
 334 ; CHECK:       # %bb.0:
 335 ; CHECK-NEXT:    addi sp, sp, -16
 336 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 337 ; CHECK-NEXT:    call __fixunstfsi
 338 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 339 ; CHECK-NEXT:    addi sp, sp, 16
 340 ; CHECK-NEXT:    ret
 341   %a = fptoui fp128 %x to i8
 342   ret i8 %a
 343 }
 344
 345 define i16 @fptoui_i16(fp128 %x) nounwind {
 346 ; CHECK-LABEL: fptoui_i16:
 347 ; CHECK:       # %bb.0:
 348 ; CHECK-NEXT:    addi sp, sp, -16
 349 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 350 ; CHECK-NEXT:    call __fixunstfsi
 351 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 352 ; CHECK-NEXT:    addi sp, sp, 16
 353 ; CHECK-NEXT:    ret
 354   %a = fptoui fp128 %x to i16
 355   ret i16 %a
 356 }
 357
 358 define i32 @fptoui_i32(fp128 %x) nounwind {
 359 ; CHECK-LABEL: fptoui_i32:
 360 ; CHECK:       # %bb.0:
 361 ; CHECK-NEXT:    addi sp, sp, -16
 362 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 363 ; CHECK-NEXT:    call __fixunstfsi
 364 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 365 ; CHECK-NEXT:    addi sp, sp, 16
 366 ; CHECK-NEXT:    ret
 367   %a = fptoui fp128 %x to i32
 368   ret i32 %a
 369 }
 370
 371 define i64 @fptoui_i64(fp128 %x) nounwind {
 372 ; CHECK-LABEL: fptoui_i64:
 373 ; CHECK:       # %bb.0:
 374 ; CHECK-NEXT:    addi sp, sp, -16
 375 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 376 ; CHECK-NEXT:    call __fixunstfdi
 377 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 378 ; CHECK-NEXT:    addi sp, sp, 16
 379 ; CHECK-NEXT:    ret
 380   %a = fptoui fp128 %x to i64
 381   ret i64 %a
 382 }
 383
 384 define i128 @fptoui_i128(fp128 %x) nounwind {
 385 ; CHECK-LABEL: fptoui_i128:
 386 ; CHECK:       # %bb.0:
 387 ; CHECK-NEXT:    addi sp, sp, -16
 388 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 389 ; CHECK-NEXT:    call __fixunstfti
 390 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 391 ; CHECK-NEXT:    addi sp, sp, 16
 392 ; CHECK-NEXT:    ret
 393   %a = fptoui fp128 %x to i128
 394   ret i128 %a
 395 }
 396
 397 define fp128 @sitofp_i8(i8 %x) nounwind {
 398 ; CHECK-LABEL: sitofp_i8:
 399 ; CHECK:       # %bb.0:
 400 ; CHECK-NEXT:    addi sp, sp, -16
 401 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 402 ; CHECK-NEXT:    slli a0, a0, 56
 403 ; CHECK-NEXT:    srai a0, a0, 56
 404 ; CHECK-NEXT:    call __floatsitf
 405 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 406 ; CHECK-NEXT:    addi sp, sp, 16
 407 ; CHECK-NEXT:    ret
 408   %a = sitofp i8 %x to fp128
 409   ret fp128 %a
 410 }
 411
 412 define fp128 @sitofp_i16(i16 %x) nounwind {
 413 ; CHECK-LABEL: sitofp_i16:
 414 ; CHECK:       # %bb.0:
 415 ; CHECK-NEXT:    addi sp, sp, -16
 416 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 417 ; CHECK-NEXT:    slli a0, a0, 48
 418 ; CHECK-NEXT:    srai a0, a0, 48
 419 ; CHECK-NEXT:    call __floatsitf
 420 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 421 ; CHECK-NEXT:    addi sp, sp, 16
 422 ; CHECK-NEXT:    ret
 423   %a = sitofp i16 %x to fp128
 424   ret fp128 %a
 425 }
 426
 427 define fp128 @sitofp_i32(i32 %x) nounwind {
 428 ; CHECK-LABEL: sitofp_i32:
 429 ; CHECK:       # %bb.0:
 430 ; CHECK-NEXT:    addi sp, sp, -16
 431 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 432 ; CHECK-NEXT:    sext.w a0, a0
 433 ; CHECK-NEXT:    call __floatsitf
 434 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 435 ; CHECK-NEXT:    addi sp, sp, 16
 436 ; CHECK-NEXT:    ret
 437   %a = sitofp i32 %x to fp128
 438   ret fp128 %a
 439 }
 440
 441 define fp128 @sitofp_i64(i64 %x) nounwind {
 442 ; CHECK-LABEL: sitofp_i64:
 443 ; CHECK:       # %bb.0:
 444 ; CHECK-NEXT:    addi sp, sp, -16
 445 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 446 ; CHECK-NEXT:    call __floatditf
 447 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 448 ; CHECK-NEXT:    addi sp, sp, 16
 449 ; CHECK-NEXT:    ret
 450   %a = sitofp i64 %x to fp128
 451   ret fp128 %a
 452 }
 453
 454 define fp128 @sitofp_i128(i128 %x) nounwind {
 455 ; CHECK-LABEL: sitofp_i128:
 456 ; CHECK:       # %bb.0:
 457 ; CHECK-NEXT:    addi sp, sp, -16
 458 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 459 ; CHECK-NEXT:    call __floattitf
 460 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 461 ; CHECK-NEXT:    addi sp, sp, 16
 462 ; CHECK-NEXT:    ret
 463   %a = sitofp i128 %x to fp128
 464   ret fp128 %a
 465 }
 466
 467 define fp128 @uitofp_i8(i8 %x) nounwind {
 468 ; CHECK-LABEL: uitofp_i8:
 469 ; CHECK:       # %bb.0:
 470 ; CHECK-NEXT:    addi sp, sp, -16
 471 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 472 ; CHECK-NEXT:    andi a0, a0, 255
 473 ; CHECK-NEXT:    call __floatunsitf
 474 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 475 ; CHECK-NEXT:    addi sp, sp, 16
 476 ; CHECK-NEXT:    ret
 477   %a = uitofp i8 %x to fp128
 478   ret fp128 %a
 479 }
 480
 481 define fp128 @uitofp_i16(i16 %x) nounwind {
 482 ; CHECK-LABEL: uitofp_i16:
 483 ; CHECK:       # %bb.0:
 484 ; CHECK-NEXT:    addi sp, sp, -16
 485 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 486 ; CHECK-NEXT:    slli a0, a0, 48
 487 ; CHECK-NEXT:    srli a0, a0, 48
 488 ; CHECK-NEXT:    call __floatunsitf
 489 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 490 ; CHECK-NEXT:    addi sp, sp, 16
 491 ; CHECK-NEXT:    ret
 492   %a = uitofp i16 %x to fp128
 493   ret fp128 %a
 494 }
 495
 496 define fp128 @uitofp_i32(i32 %x) nounwind {
 497 ; CHECK-LABEL: uitofp_i32:
 498 ; CHECK:       # %bb.0:
 499 ; CHECK-NEXT:    addi sp, sp, -16
 500 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 501 ; CHECK-NEXT:    sext.w a0, a0
 502 ; CHECK-NEXT:    call __floatunsitf
 503 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 504 ; CHECK-NEXT:    addi sp, sp, 16
 505 ; CHECK-NEXT:    ret
 506   %a = uitofp i32 %x to fp128
 507   ret fp128 %a
 508 }
 509
 510 define fp128 @uitofp_i64(i64 %x) nounwind {
 511 ; CHECK-LABEL: uitofp_i64:
 512 ; CHECK:       # %bb.0:
 513 ; CHECK-NEXT:    addi sp, sp, -16
 514 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 515 ; CHECK-NEXT:    call __floatunditf
 516 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 517 ; CHECK-NEXT:    addi sp, sp, 16
 518 ; CHECK-NEXT:    ret
 519   %a = uitofp i64 %x to fp128
 520   ret fp128 %a
 521 }
 522
 523 define fp128 @uitofp_i128(i128 %x) nounwind {
 524 ; CHECK-LABEL: uitofp_i128:
 525 ; CHECK:       # %bb.0:
 526 ; CHECK-NEXT:    addi sp, sp, -16
 527 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 528 ; CHECK-NEXT:    call __floatuntitf
 529 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 530 ; CHECK-NEXT:    addi sp, sp, 16
 531 ; CHECK-NEXT:    ret
 532   %a = uitofp i128 %x to fp128
 533   ret fp128 %a
 534 }
 535
 536 define fp128 @sqrt(fp128 %a) nounwind {
 537 ; CHECK-LABEL: sqrt:
 538 ; CHECK:       # %bb.0:
 539 ; CHECK-NEXT:    addi sp, sp, -16
 540 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 541 ; CHECK-NEXT:    call sqrtl
 542 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 543 ; CHECK-NEXT:    addi sp, sp, 16
 544 ; CHECK-NEXT:    ret
 545   %1 = call fp128 @llvm.sqrt.f128(fp128 %a)
 546   ret fp128 %1
 547 }
 548
 549 define fp128 @powi(fp128 %a, i32 %b) nounwind {
 550 ; CHECK-LABEL: powi:
 551 ; CHECK:       # %bb.0:
 552 ; CHECK-NEXT:    addi sp, sp, -16
 553 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 554 ; CHECK-NEXT:    sext.w a2, a2
 555 ; CHECK-NEXT:    call __powitf2
 556 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 557 ; CHECK-NEXT:    addi sp, sp, 16
 558 ; CHECK-NEXT:    ret
 559   %1 = call fp128 @llvm.powi.f128.i32(fp128 %a, i32 %b)
 560   ret fp128 %1
 561 }
 562
 563 define fp128 @sin(fp128 %a) nounwind {
 564 ; CHECK-LABEL: sin:
 565 ; CHECK:       # %bb.0:
 566 ; CHECK-NEXT:    addi sp, sp, -16
 567 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 568 ; CHECK-NEXT:    call sinl
 569 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 570 ; CHECK-NEXT:    addi sp, sp, 16
 571 ; CHECK-NEXT:    ret
 572   %1 = call fp128 @llvm.sin.f128(fp128 %a)
 573   ret fp128 %1
 574 }
 575
 576 define fp128 @cos(fp128 %a) nounwind {
 577 ; CHECK-LABEL: cos:
 578 ; CHECK:       # %bb.0:
 579 ; CHECK-NEXT:    addi sp, sp, -16
 580 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 581 ; CHECK-NEXT:    call cosl
 582 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 583 ; CHECK-NEXT:    addi sp, sp, 16
 584 ; CHECK-NEXT:    ret
 585   %1 = call fp128 @llvm.cos.f128(fp128 %a)
 586   ret fp128 %1
 587 }
 588
 589 define fp128 @pow(fp128 %a, fp128 %b) nounwind {
 590 ; CHECK-LABEL: pow:
 591 ; CHECK:       # %bb.0:
 592 ; CHECK-NEXT:    addi sp, sp, -16
 593 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 594 ; CHECK-NEXT:    call powl
 595 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 596 ; CHECK-NEXT:    addi sp, sp, 16
 597 ; CHECK-NEXT:    ret
 598   %1 = call fp128 @llvm.pow.f128(fp128 %a, fp128 %b)
 599   ret fp128 %1
 600 }
 601
 602 define fp128 @exp(fp128 %a) nounwind {
 603 ; CHECK-LABEL: exp:
 604 ; CHECK:       # %bb.0:
 605 ; CHECK-NEXT:    addi sp, sp, -16
 606 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 607 ; CHECK-NEXT:    call expl
 608 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 609 ; CHECK-NEXT:    addi sp, sp, 16
 610 ; CHECK-NEXT:    ret
 611   %1 = call fp128 @llvm.exp.f128(fp128 %a)
 612   ret fp128 %1
 613 }
 614
 615 define fp128 @exp2(fp128 %a) nounwind {
 616 ; CHECK-LABEL: exp2:
 617 ; CHECK:       # %bb.0:
 618 ; CHECK-NEXT:    addi sp, sp, -16
 619 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 620 ; CHECK-NEXT:    call exp2l
 621 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 622 ; CHECK-NEXT:    addi sp, sp, 16
 623 ; CHECK-NEXT:    ret
 624   %1 = call fp128 @llvm.exp2.f128(fp128 %a)
 625   ret fp128 %1
 626 }
 627
 628 define fp128 @exp10(fp128 %a) nounwind {
 629 ; CHECK-LABEL: exp10:
 630 ; CHECK:       # %bb.0:
 631 ; CHECK-NEXT:    addi sp, sp, -16
 632 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 633 ; CHECK-NEXT:    call exp10l
 634 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 635 ; CHECK-NEXT:    addi sp, sp, 16
 636 ; CHECK-NEXT:    ret
 637   %1 = call fp128 @llvm.exp10.f128(fp128 %a)
 638   ret fp128 %1
 639 }
 640
 641 define fp128 @log(fp128 %a) nounwind {
 642 ; CHECK-LABEL: log:
 643 ; CHECK:       # %bb.0:
 644 ; CHECK-NEXT:    addi sp, sp, -16
 645 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 646 ; CHECK-NEXT:    call logl
 647 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 648 ; CHECK-NEXT:    addi sp, sp, 16
 649 ; CHECK-NEXT:    ret
 650   %1 = call fp128 @llvm.log.f128(fp128 %a)
 651   ret fp128 %1
 652 }
 653
 654 define fp128 @log10(fp128 %a) nounwind {
 655 ; CHECK-LABEL: log10:
 656 ; CHECK:       # %bb.0:
 657 ; CHECK-NEXT:    addi sp, sp, -16
 658 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 659 ; CHECK-NEXT:    call log10l
 660 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 661 ; CHECK-NEXT:    addi sp, sp, 16
 662 ; CHECK-NEXT:    ret
 663   %1 = call fp128 @llvm.log10.f128(fp128 %a)
 664   ret fp128 %1
 665 }
 666
 667 define fp128 @log2(fp128 %a) nounwind {
 668 ; CHECK-LABEL: log2:
 669 ; CHECK:       # %bb.0:
 670 ; CHECK-NEXT:    addi sp, sp, -16
 671 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 672 ; CHECK-NEXT:    call log2l
 673 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 674 ; CHECK-NEXT:    addi sp, sp, 16
 675 ; CHECK-NEXT:    ret
 676   %1 = call fp128 @llvm.log2.f128(fp128 %a)
 677   ret fp128 %1
 678 }
 679
 680 define fp128 @minnum(fp128 %a, fp128 %b) nounwind {
 681 ; CHECK-LABEL: minnum:
 682 ; CHECK:       # %bb.0:
 683 ; CHECK-NEXT:    addi sp, sp, -16
 684 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 685 ; CHECK-NEXT:    call fminl
 686 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 687 ; CHECK-NEXT:    addi sp, sp, 16
 688 ; CHECK-NEXT:    ret
 689   %1 = call fp128 @llvm.minnum.f128(fp128 %a, fp128 %b)
 690   ret fp128 %1
 691 }
 692
 693 define fp128 @maxnum(fp128 %a, fp128 %b) nounwind {
 694 ; CHECK-LABEL: maxnum:
 695 ; CHECK:       # %bb.0:
 696 ; CHECK-NEXT:    addi sp, sp, -16
 697 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 698 ; CHECK-NEXT:    call fmaxl
 699 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 700 ; CHECK-NEXT:    addi sp, sp, 16
 701 ; CHECK-NEXT:    ret
 702   %1 = call fp128 @llvm.maxnum.f128(fp128 %a, fp128 %b)
 703   ret fp128 %1
 704 }
 705
 706 define fp128 @floor(fp128 %a) nounwind {
 707 ; CHECK-LABEL: floor:
 708 ; CHECK:       # %bb.0:
 709 ; CHECK-NEXT:    addi sp, sp, -16
 710 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 711 ; CHECK-NEXT:    call floorl
 712 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 713 ; CHECK-NEXT:    addi sp, sp, 16
 714 ; CHECK-NEXT:    ret
 715   %1 = call fp128 @llvm.floor.f128(fp128 %a)
 716   ret fp128 %1
 717 }
 718
 719 define fp128 @ceil(fp128 %a) nounwind {
 720 ; CHECK-LABEL: ceil:
 721 ; CHECK:       # %bb.0:
 722 ; CHECK-NEXT:    addi sp, sp, -16
 723 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 724 ; CHECK-NEXT:    call ceill
 725 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 726 ; CHECK-NEXT:    addi sp, sp, 16
 727 ; CHECK-NEXT:    ret
 728   %1 = call fp128 @llvm.ceil.f128(fp128 %a)
 729   ret fp128 %1
 730 }
 731
 732 define fp128 @trunc(fp128 %a) nounwind {
 733 ; CHECK-LABEL: trunc:
 734 ; CHECK:       # %bb.0:
 735 ; CHECK-NEXT:    addi sp, sp, -16
 736 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 737 ; CHECK-NEXT:    call truncl
 738 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 739 ; CHECK-NEXT:    addi sp, sp, 16
 740 ; CHECK-NEXT:    ret
 741   %1 = call fp128 @llvm.trunc.f128(fp128 %a)
 742   ret fp128 %1
 743 }
 744
 745 define fp128 @rint(fp128 %a) nounwind {
 746 ; CHECK-LABEL: rint:
 747 ; CHECK:       # %bb.0:
 748 ; CHECK-NEXT:    addi sp, sp, -16
 749 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 750 ; CHECK-NEXT:    call rintl
 751 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 752 ; CHECK-NEXT:    addi sp, sp, 16
 753 ; CHECK-NEXT:    ret
 754   %1 = call fp128 @llvm.rint.f128(fp128 %a)
 755   ret fp128 %1
 756 }
 757
 758 define fp128 @nearbyint(fp128 %a) nounwind {
 759 ; CHECK-LABEL: nearbyint:
 760 ; CHECK:       # %bb.0:
 761 ; CHECK-NEXT:    addi sp, sp, -16
 762 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 763 ; CHECK-NEXT:    call nearbyintl
 764 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 765 ; CHECK-NEXT:    addi sp, sp, 16
 766 ; CHECK-NEXT:    ret
 767   %1 = call fp128 @llvm.nearbyint.f128(fp128 %a)
 768   ret fp128 %1
 769 }
 770
 771 define fp128 @round(fp128 %a) nounwind {
 772 ; CHECK-LABEL: round:
 773 ; CHECK:       # %bb.0:
 774 ; CHECK-NEXT:    addi sp, sp, -16
 775 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 776 ; CHECK-NEXT:    call roundl
 777 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 778 ; CHECK-NEXT:    addi sp, sp, 16
 779 ; CHECK-NEXT:    ret
 780   %1 = call fp128 @llvm.round.f128(fp128 %a)
 781   ret fp128 %1
 782 }
 783
 784 define fp128 @roundeven(fp128 %a) nounwind {
 785 ; CHECK-LABEL: roundeven:
 786 ; CHECK:       # %bb.0:
 787 ; CHECK-NEXT:    addi sp, sp, -16
 788 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 789 ; CHECK-NEXT:    call roundevenl
 790 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 791 ; CHECK-NEXT:    addi sp, sp, 16
 792 ; CHECK-NEXT:    ret
 793   %1 = call fp128 @llvm.roundeven.f128(fp128 %a)
 794   ret fp128 %1
 795 }
 796
 797 define fp128 @tan(fp128 %a) nounwind {
 798 ; CHECK-LABEL: tan:
 799 ; CHECK:       # %bb.0:
 800 ; CHECK-NEXT:    addi sp, sp, -16
 801 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 802 ; CHECK-NEXT:    call tanl
 803 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 804 ; CHECK-NEXT:    addi sp, sp, 16
 805 ; CHECK-NEXT:    ret
 806   %1 = call fp128 @llvm.tan.f128(fp128 %a)
 807   ret fp128 %1
 808 }
 809
 810 define fp128 @ldexp_fp128(fp128 %x, i32 %y) nounwind {
 811 ; CHECK-LABEL: ldexp_fp128:
 812 ; CHECK:       # %bb.0:
 813 ; CHECK-NEXT:    addi sp, sp, -16
 814 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 815 ; CHECK-NEXT:    sext.w a2, a2
 816 ; CHECK-NEXT:    call ldexpl
 817 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 818 ; CHECK-NEXT:    addi sp, sp, 16
 819 ; CHECK-NEXT:    ret
 820   %z = call fp128 @llvm.ldexp.f128.i32(fp128 %x, i32 %y)
 821   ret fp128 %z
 822 }
 823
 824 define fp128 @asin(fp128 %a) nounwind {
 825 ; CHECK-LABEL: asin:
 826 ; CHECK:       # %bb.0:
 827 ; CHECK-NEXT:    addi sp, sp, -16
 828 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 829 ; CHECK-NEXT:    call asinl
 830 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 831 ; CHECK-NEXT:    addi sp, sp, 16
 832 ; CHECK-NEXT:    ret
 833   %1 = call fp128 @llvm.asin.f128(fp128 %a)
 834   ret fp128 %1
 835 }
 836
 837 define fp128 @acos(fp128 %a) nounwind {
 838 ; CHECK-LABEL: acos:
 839 ; CHECK:       # %bb.0:
 840 ; CHECK-NEXT:    addi sp, sp, -16
 841 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 842 ; CHECK-NEXT:    call acosl
 843 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 844 ; CHECK-NEXT:    addi sp, sp, 16
 845 ; CHECK-NEXT:    ret
 846   %1 = call fp128 @llvm.acos.f128(fp128 %a)
 847   ret fp128 %1
 848 }
 849
 850 define fp128 @atan(fp128 %a) nounwind {
 851 ; CHECK-LABEL: atan:
 852 ; CHECK:       # %bb.0:
 853 ; CHECK-NEXT:    addi sp, sp, -16
 854 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 855 ; CHECK-NEXT:    call atanl
 856 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 857 ; CHECK-NEXT:    addi sp, sp, 16
 858 ; CHECK-NEXT:    ret
 859   %1 = call fp128 @llvm.atan.f128(fp128 %a)
 860   ret fp128 %1
 861 }
 862
 863 define fp128 @atan2(fp128 %a, fp128 %b) nounwind {
 864 ; CHECK-LABEL: atan2:
 865 ; CHECK:       # %bb.0:
 866 ; CHECK-NEXT:    addi sp, sp, -16
 867 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 868 ; CHECK-NEXT:    call atan2l
 869 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 870 ; CHECK-NEXT:    addi sp, sp, 16
 871 ; CHECK-NEXT:    ret
 872   %1 = call fp128 @llvm.atan2.f128(fp128 %a, fp128 %b)
 873   ret fp128 %1
 874 }
 875
 876 define fp128 @sinh(fp128 %a) nounwind {
 877 ; CHECK-LABEL: sinh:
 878 ; CHECK:       # %bb.0:
 879 ; CHECK-NEXT:    addi sp, sp, -16
 880 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 881 ; CHECK-NEXT:    call sinhl
 882 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 883 ; CHECK-NEXT:    addi sp, sp, 16
 884 ; CHECK-NEXT:    ret
 885   %1 = call fp128 @llvm.sinh.f128(fp128 %a)
 886   ret fp128 %1
 887 }
 888
 889 define fp128 @cosh(fp128 %a) nounwind {
 890 ; CHECK-LABEL: cosh:
 891 ; CHECK:       # %bb.0:
 892 ; CHECK-NEXT:    addi sp, sp, -16
 893 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 894 ; CHECK-NEXT:    call coshl
 895 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 896 ; CHECK-NEXT:    addi sp, sp, 16
 897 ; CHECK-NEXT:    ret
 898   %1 = call fp128 @llvm.cosh.f128(fp128 %a)
 899   ret fp128 %1
 900 }
 901
 902 define fp128 @tanh(fp128 %a) nounwind {
 903 ; CHECK-LABEL: tanh:
 904 ; CHECK:       # %bb.0:
 905 ; CHECK-NEXT:    addi sp, sp, -16
 906 ; CHECK-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 907 ; CHECK-NEXT:    call tanhl
 908 ; CHECK-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 909 ; CHECK-NEXT:    addi sp, sp, 16
 910 ; CHECK-NEXT:    ret
 911   %1 = call fp128 @llvm.tanh.f128(fp128 %a)
 912   ret fp128 %1
 913 }