llvm/test/CodeGen/RISCV/double-intrinsics.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: sed 's/iXLen/i32/g' %s | llc -mtriple=riscv32 -mattr=+d \
   3 ; RUN:   -verify-machineinstrs -target-abi=ilp32d \
   4 ; RUN:   | FileCheck -check-prefixes=CHECKIFD,RV32IFD %s
   5 ; RUN: sed 's/iXLen/i64/g' %s | llc -mtriple=riscv64 -mattr=+d \
   6 ; RUN:   -verify-machineinstrs -target-abi=lp64d \
   7 ; RUN:   | FileCheck -check-prefixes=CHECKIFD,RV64IFD %s
   8 ; RUN: sed 's/iXLen/i32/g' %s | llc -mtriple=riscv32 -mattr=+zdinx \
   9 ; RUN:   -verify-machineinstrs -target-abi=ilp32 \
  10 ; RUN:   | FileCheck -check-prefix=RV32IZFINXZDINX %s
  11 ; RUN: sed 's/iXLen/i64/g' %s | llc -mtriple=riscv64 -mattr=+zdinx \
  12 ; RUN:   -verify-machineinstrs -target-abi=lp64 \
  13 ; RUN:   | FileCheck -check-prefix=RV64IZFINXZDINX %s
  14 ; RUN: sed 's/iXLen/i32/g' %s | llc -mtriple=riscv32 \
  15 ; RUN:   -verify-machineinstrs | FileCheck -check-prefix=RV32I %s
  16 ; RUN: sed 's/iXLen/i64/g' %s | llc -mtriple=riscv64 \
  17 ; RUN:   -verify-machineinstrs | FileCheck -check-prefix=RV64I %s
  18
  19 declare double @llvm.sqrt.f64(double)
  20
  21 define double @sqrt_f64(double %a) nounwind {
  22 ; CHECKIFD-LABEL: sqrt_f64:
  23 ; CHECKIFD:       # %bb.0:
  24 ; CHECKIFD-NEXT:    fsqrt.d fa0, fa0
  25 ; CHECKIFD-NEXT:    ret
  26 ;
  27 ; RV32IZFINXZDINX-LABEL: sqrt_f64:
  28 ; RV32IZFINXZDINX:       # %bb.0:
  29 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
  30 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
  31 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
  32 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
  33 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
  34 ; RV32IZFINXZDINX-NEXT:    fsqrt.d a0, a0
  35 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
  36 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
  37 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
  38 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
  39 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
  40 ; RV32IZFINXZDINX-NEXT:    ret
  41 ;
  42 ; RV64IZFINXZDINX-LABEL: sqrt_f64:
  43 ; RV64IZFINXZDINX:       # %bb.0:
  44 ; RV64IZFINXZDINX-NEXT:    fsqrt.d a0, a0
  45 ; RV64IZFINXZDINX-NEXT:    ret
  46 ;
  47 ; RV32I-LABEL: sqrt_f64:
  48 ; RV32I:       # %bb.0:
  49 ; RV32I-NEXT:    addi sp, sp, -16
  50 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
  51 ; RV32I-NEXT:    call sqrt
  52 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
  53 ; RV32I-NEXT:    addi sp, sp, 16
  54 ; RV32I-NEXT:    ret
  55 ;
  56 ; RV64I-LABEL: sqrt_f64:
  57 ; RV64I:       # %bb.0:
  58 ; RV64I-NEXT:    addi sp, sp, -16
  59 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  60 ; RV64I-NEXT:    call sqrt
  61 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  62 ; RV64I-NEXT:    addi sp, sp, 16
  63 ; RV64I-NEXT:    ret
  64   %1 = call double @llvm.sqrt.f64(double %a)
  65   ret double %1
  66 }
  67
  68 declare double @llvm.powi.f64.i32(double, i32)
  69
  70 define double @powi_f64(double %a, i32 %b) nounwind {
  71 ; RV32IFD-LABEL: powi_f64:
  72 ; RV32IFD:       # %bb.0:
  73 ; RV32IFD-NEXT:    tail __powidf2
  74 ;
  75 ; RV64IFD-LABEL: powi_f64:
  76 ; RV64IFD:       # %bb.0:
  77 ; RV64IFD-NEXT:    addi sp, sp, -16
  78 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  79 ; RV64IFD-NEXT:    sext.w a0, a0
  80 ; RV64IFD-NEXT:    call __powidf2
  81 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  82 ; RV64IFD-NEXT:    addi sp, sp, 16
  83 ; RV64IFD-NEXT:    ret
  84 ;
  85 ; RV32IZFINXZDINX-LABEL: powi_f64:
  86 ; RV32IZFINXZDINX:       # %bb.0:
  87 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
  88 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
  89 ; RV32IZFINXZDINX-NEXT:    call __powidf2
  90 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
  91 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
  92 ; RV32IZFINXZDINX-NEXT:    ret
  93 ;
  94 ; RV64IZFINXZDINX-LABEL: powi_f64:
  95 ; RV64IZFINXZDINX:       # %bb.0:
  96 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
  97 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  98 ; RV64IZFINXZDINX-NEXT:    sext.w a1, a1
  99 ; RV64IZFINXZDINX-NEXT:    call __powidf2
 100 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 101 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
 102 ; RV64IZFINXZDINX-NEXT:    ret
 103 ;
 104 ; RV32I-LABEL: powi_f64:
 105 ; RV32I:       # %bb.0:
 106 ; RV32I-NEXT:    addi sp, sp, -16
 107 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 108 ; RV32I-NEXT:    call __powidf2
 109 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 110 ; RV32I-NEXT:    addi sp, sp, 16
 111 ; RV32I-NEXT:    ret
 112 ;
 113 ; RV64I-LABEL: powi_f64:
 114 ; RV64I:       # %bb.0:
 115 ; RV64I-NEXT:    addi sp, sp, -16
 116 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 117 ; RV64I-NEXT:    sext.w a1, a1
 118 ; RV64I-NEXT:    call __powidf2
 119 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 120 ; RV64I-NEXT:    addi sp, sp, 16
 121 ; RV64I-NEXT:    ret
 122   %1 = call double @llvm.powi.f64.i32(double %a, i32 %b)
 123   ret double %1
 124 }
 125
 126 declare double @llvm.sin.f64(double)
 127
 128 define double @sin_f64(double %a) nounwind {
 129 ; CHECKIFD-LABEL: sin_f64:
 130 ; CHECKIFD:       # %bb.0:
 131 ; CHECKIFD-NEXT:    tail sin
 132 ;
 133 ; RV32IZFINXZDINX-LABEL: sin_f64:
 134 ; RV32IZFINXZDINX:       # %bb.0:
 135 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 136 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 137 ; RV32IZFINXZDINX-NEXT:    call sin
 138 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 139 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 140 ; RV32IZFINXZDINX-NEXT:    ret
 141 ;
 142 ; RV64IZFINXZDINX-LABEL: sin_f64:
 143 ; RV64IZFINXZDINX:       # %bb.0:
 144 ; RV64IZFINXZDINX-NEXT:    tail sin
 145 ;
 146 ; RV32I-LABEL: sin_f64:
 147 ; RV32I:       # %bb.0:
 148 ; RV32I-NEXT:    addi sp, sp, -16
 149 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 150 ; RV32I-NEXT:    call sin
 151 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 152 ; RV32I-NEXT:    addi sp, sp, 16
 153 ; RV32I-NEXT:    ret
 154 ;
 155 ; RV64I-LABEL: sin_f64:
 156 ; RV64I:       # %bb.0:
 157 ; RV64I-NEXT:    addi sp, sp, -16
 158 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 159 ; RV64I-NEXT:    call sin
 160 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 161 ; RV64I-NEXT:    addi sp, sp, 16
 162 ; RV64I-NEXT:    ret
 163   %1 = call double @llvm.sin.f64(double %a)
 164   ret double %1
 165 }
 166
 167 declare double @llvm.cos.f64(double)
 168
 169 define double @cos_f64(double %a) nounwind {
 170 ; CHECKIFD-LABEL: cos_f64:
 171 ; CHECKIFD:       # %bb.0:
 172 ; CHECKIFD-NEXT:    tail cos
 173 ;
 174 ; RV32IZFINXZDINX-LABEL: cos_f64:
 175 ; RV32IZFINXZDINX:       # %bb.0:
 176 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 177 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 178 ; RV32IZFINXZDINX-NEXT:    call cos
 179 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 180 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 181 ; RV32IZFINXZDINX-NEXT:    ret
 182 ;
 183 ; RV64IZFINXZDINX-LABEL: cos_f64:
 184 ; RV64IZFINXZDINX:       # %bb.0:
 185 ; RV64IZFINXZDINX-NEXT:    tail cos
 186 ;
 187 ; RV32I-LABEL: cos_f64:
 188 ; RV32I:       # %bb.0:
 189 ; RV32I-NEXT:    addi sp, sp, -16
 190 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 191 ; RV32I-NEXT:    call cos
 192 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 193 ; RV32I-NEXT:    addi sp, sp, 16
 194 ; RV32I-NEXT:    ret
 195 ;
 196 ; RV64I-LABEL: cos_f64:
 197 ; RV64I:       # %bb.0:
 198 ; RV64I-NEXT:    addi sp, sp, -16
 199 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 200 ; RV64I-NEXT:    call cos
 201 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 202 ; RV64I-NEXT:    addi sp, sp, 16
 203 ; RV64I-NEXT:    ret
 204   %1 = call double @llvm.cos.f64(double %a)
 205   ret double %1
 206 }
 207
 208 ; The sin+cos combination results in an FSINCOS SelectionDAG node.
 209 define double @sincos_f64(double %a) nounwind {
 210 ; RV32IFD-LABEL: sincos_f64:
 211 ; RV32IFD:       # %bb.0:
 212 ; RV32IFD-NEXT:    addi sp, sp, -32
 213 ; RV32IFD-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 214 ; RV32IFD-NEXT:    fsd fs0, 16(sp) # 8-byte Folded Spill
 215 ; RV32IFD-NEXT:    fsd fs1, 8(sp) # 8-byte Folded Spill
 216 ; RV32IFD-NEXT:    fmv.d fs0, fa0
 217 ; RV32IFD-NEXT:    call sin
 218 ; RV32IFD-NEXT:    fmv.d fs1, fa0
 219 ; RV32IFD-NEXT:    fmv.d fa0, fs0
 220 ; RV32IFD-NEXT:    call cos
 221 ; RV32IFD-NEXT:    fadd.d fa0, fs1, fa0
 222 ; RV32IFD-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
 223 ; RV32IFD-NEXT:    fld fs0, 16(sp) # 8-byte Folded Reload
 224 ; RV32IFD-NEXT:    fld fs1, 8(sp) # 8-byte Folded Reload
 225 ; RV32IFD-NEXT:    addi sp, sp, 32
 226 ; RV32IFD-NEXT:    ret
 227 ;
 228 ; RV64IFD-LABEL: sincos_f64:
 229 ; RV64IFD:       # %bb.0:
 230 ; RV64IFD-NEXT:    addi sp, sp, -32
 231 ; RV64IFD-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
 232 ; RV64IFD-NEXT:    fsd fs0, 16(sp) # 8-byte Folded Spill
 233 ; RV64IFD-NEXT:    fsd fs1, 8(sp) # 8-byte Folded Spill
 234 ; RV64IFD-NEXT:    fmv.d fs0, fa0
 235 ; RV64IFD-NEXT:    call sin
 236 ; RV64IFD-NEXT:    fmv.d fs1, fa0
 237 ; RV64IFD-NEXT:    fmv.d fa0, fs0
 238 ; RV64IFD-NEXT:    call cos
 239 ; RV64IFD-NEXT:    fadd.d fa0, fs1, fa0
 240 ; RV64IFD-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
 241 ; RV64IFD-NEXT:    fld fs0, 16(sp) # 8-byte Folded Reload
 242 ; RV64IFD-NEXT:    fld fs1, 8(sp) # 8-byte Folded Reload
 243 ; RV64IFD-NEXT:    addi sp, sp, 32
 244 ; RV64IFD-NEXT:    ret
 245 ;
 246 ; RV32IZFINXZDINX-LABEL: sincos_f64:
 247 ; RV32IZFINXZDINX:       # %bb.0:
 248 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -32
 249 ; RV32IZFINXZDINX-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 250 ; RV32IZFINXZDINX-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 251 ; RV32IZFINXZDINX-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill
 252 ; RV32IZFINXZDINX-NEXT:    sw s2, 16(sp) # 4-byte Folded Spill
 253 ; RV32IZFINXZDINX-NEXT:    sw s3, 12(sp) # 4-byte Folded Spill
 254 ; RV32IZFINXZDINX-NEXT:    mv s0, a1
 255 ; RV32IZFINXZDINX-NEXT:    mv s1, a0
 256 ; RV32IZFINXZDINX-NEXT:    call sin
 257 ; RV32IZFINXZDINX-NEXT:    sw a0, 0(sp)
 258 ; RV32IZFINXZDINX-NEXT:    sw a1, 4(sp)
 259 ; RV32IZFINXZDINX-NEXT:    lw s2, 0(sp)
 260 ; RV32IZFINXZDINX-NEXT:    lw s3, 4(sp)
 261 ; RV32IZFINXZDINX-NEXT:    mv a0, s1
 262 ; RV32IZFINXZDINX-NEXT:    mv a1, s0
 263 ; RV32IZFINXZDINX-NEXT:    call cos
 264 ; RV32IZFINXZDINX-NEXT:    sw a0, 0(sp)
 265 ; RV32IZFINXZDINX-NEXT:    sw a1, 4(sp)
 266 ; RV32IZFINXZDINX-NEXT:    lw a0, 0(sp)
 267 ; RV32IZFINXZDINX-NEXT:    lw a1, 4(sp)
 268 ; RV32IZFINXZDINX-NEXT:    fadd.d a0, s2, a0
 269 ; RV32IZFINXZDINX-NEXT:    sw a0, 0(sp)
 270 ; RV32IZFINXZDINX-NEXT:    sw a1, 4(sp)
 271 ; RV32IZFINXZDINX-NEXT:    lw a0, 0(sp)
 272 ; RV32IZFINXZDINX-NEXT:    lw a1, 4(sp)
 273 ; RV32IZFINXZDINX-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
 274 ; RV32IZFINXZDINX-NEXT:    lw s0, 24(sp) # 4-byte Folded Reload
 275 ; RV32IZFINXZDINX-NEXT:    lw s1, 20(sp) # 4-byte Folded Reload
 276 ; RV32IZFINXZDINX-NEXT:    lw s2, 16(sp) # 4-byte Folded Reload
 277 ; RV32IZFINXZDINX-NEXT:    lw s3, 12(sp) # 4-byte Folded Reload
 278 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 32
 279 ; RV32IZFINXZDINX-NEXT:    ret
 280 ;
 281 ; RV64IZFINXZDINX-LABEL: sincos_f64:
 282 ; RV64IZFINXZDINX:       # %bb.0:
 283 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -32
 284 ; RV64IZFINXZDINX-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
 285 ; RV64IZFINXZDINX-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
 286 ; RV64IZFINXZDINX-NEXT:    sd s1, 8(sp) # 8-byte Folded Spill
 287 ; RV64IZFINXZDINX-NEXT:    mv s0, a0
 288 ; RV64IZFINXZDINX-NEXT:    call sin
 289 ; RV64IZFINXZDINX-NEXT:    mv s1, a0
 290 ; RV64IZFINXZDINX-NEXT:    mv a0, s0
 291 ; RV64IZFINXZDINX-NEXT:    call cos
 292 ; RV64IZFINXZDINX-NEXT:    fadd.d a0, s1, a0
 293 ; RV64IZFINXZDINX-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
 294 ; RV64IZFINXZDINX-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
 295 ; RV64IZFINXZDINX-NEXT:    ld s1, 8(sp) # 8-byte Folded Reload
 296 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 32
 297 ; RV64IZFINXZDINX-NEXT:    ret
 298 ;
 299 ; RV32I-LABEL: sincos_f64:
 300 ; RV32I:       # %bb.0:
 301 ; RV32I-NEXT:    addi sp, sp, -32
 302 ; RV32I-NEXT:    sw ra, 28(sp) # 4-byte Folded Spill
 303 ; RV32I-NEXT:    sw s0, 24(sp) # 4-byte Folded Spill
 304 ; RV32I-NEXT:    sw s1, 20(sp) # 4-byte Folded Spill
 305 ; RV32I-NEXT:    sw s2, 16(sp) # 4-byte Folded Spill
 306 ; RV32I-NEXT:    sw s3, 12(sp) # 4-byte Folded Spill
 307 ; RV32I-NEXT:    mv s0, a1
 308 ; RV32I-NEXT:    mv s1, a0
 309 ; RV32I-NEXT:    call sin
 310 ; RV32I-NEXT:    mv s2, a0
 311 ; RV32I-NEXT:    mv s3, a1
 312 ; RV32I-NEXT:    mv a0, s1
 313 ; RV32I-NEXT:    mv a1, s0
 314 ; RV32I-NEXT:    call cos
 315 ; RV32I-NEXT:    mv a2, a0
 316 ; RV32I-NEXT:    mv a3, a1
 317 ; RV32I-NEXT:    mv a0, s2
 318 ; RV32I-NEXT:    mv a1, s3
 319 ; RV32I-NEXT:    call __adddf3
 320 ; RV32I-NEXT:    lw ra, 28(sp) # 4-byte Folded Reload
 321 ; RV32I-NEXT:    lw s0, 24(sp) # 4-byte Folded Reload
 322 ; RV32I-NEXT:    lw s1, 20(sp) # 4-byte Folded Reload
 323 ; RV32I-NEXT:    lw s2, 16(sp) # 4-byte Folded Reload
 324 ; RV32I-NEXT:    lw s3, 12(sp) # 4-byte Folded Reload
 325 ; RV32I-NEXT:    addi sp, sp, 32
 326 ; RV32I-NEXT:    ret
 327 ;
 328 ; RV64I-LABEL: sincos_f64:
 329 ; RV64I:       # %bb.0:
 330 ; RV64I-NEXT:    addi sp, sp, -32
 331 ; RV64I-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
 332 ; RV64I-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
 333 ; RV64I-NEXT:    sd s1, 8(sp) # 8-byte Folded Spill
 334 ; RV64I-NEXT:    mv s0, a0
 335 ; RV64I-NEXT:    call sin
 336 ; RV64I-NEXT:    mv s1, a0
 337 ; RV64I-NEXT:    mv a0, s0
 338 ; RV64I-NEXT:    call cos
 339 ; RV64I-NEXT:    mv a1, a0
 340 ; RV64I-NEXT:    mv a0, s1
 341 ; RV64I-NEXT:    call __adddf3
 342 ; RV64I-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
 343 ; RV64I-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
 344 ; RV64I-NEXT:    ld s1, 8(sp) # 8-byte Folded Reload
 345 ; RV64I-NEXT:    addi sp, sp, 32
 346 ; RV64I-NEXT:    ret
 347   %1 = call double @llvm.sin.f64(double %a)
 348   %2 = call double @llvm.cos.f64(double %a)
 349   %3 = fadd double %1, %2
 350   ret double %3
 351 }
 352
 353 declare double @llvm.pow.f64(double, double)
 354
 355 define double @pow_f64(double %a, double %b) nounwind {
 356 ; CHECKIFD-LABEL: pow_f64:
 357 ; CHECKIFD:       # %bb.0:
 358 ; CHECKIFD-NEXT:    tail pow
 359 ;
 360 ; RV32IZFINXZDINX-LABEL: pow_f64:
 361 ; RV32IZFINXZDINX:       # %bb.0:
 362 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 363 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 364 ; RV32IZFINXZDINX-NEXT:    call pow
 365 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 366 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 367 ; RV32IZFINXZDINX-NEXT:    ret
 368 ;
 369 ; RV64IZFINXZDINX-LABEL: pow_f64:
 370 ; RV64IZFINXZDINX:       # %bb.0:
 371 ; RV64IZFINXZDINX-NEXT:    tail pow
 372 ;
 373 ; RV32I-LABEL: pow_f64:
 374 ; RV32I:       # %bb.0:
 375 ; RV32I-NEXT:    addi sp, sp, -16
 376 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 377 ; RV32I-NEXT:    call pow
 378 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 379 ; RV32I-NEXT:    addi sp, sp, 16
 380 ; RV32I-NEXT:    ret
 381 ;
 382 ; RV64I-LABEL: pow_f64:
 383 ; RV64I:       # %bb.0:
 384 ; RV64I-NEXT:    addi sp, sp, -16
 385 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 386 ; RV64I-NEXT:    call pow
 387 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 388 ; RV64I-NEXT:    addi sp, sp, 16
 389 ; RV64I-NEXT:    ret
 390   %1 = call double @llvm.pow.f64(double %a, double %b)
 391   ret double %1
 392 }
 393
 394 declare double @llvm.exp.f64(double)
 395
 396 define double @exp_f64(double %a) nounwind {
 397 ; CHECKIFD-LABEL: exp_f64:
 398 ; CHECKIFD:       # %bb.0:
 399 ; CHECKIFD-NEXT:    tail exp
 400 ;
 401 ; RV32IZFINXZDINX-LABEL: exp_f64:
 402 ; RV32IZFINXZDINX:       # %bb.0:
 403 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 404 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 405 ; RV32IZFINXZDINX-NEXT:    call exp
 406 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 407 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 408 ; RV32IZFINXZDINX-NEXT:    ret
 409 ;
 410 ; RV64IZFINXZDINX-LABEL: exp_f64:
 411 ; RV64IZFINXZDINX:       # %bb.0:
 412 ; RV64IZFINXZDINX-NEXT:    tail exp
 413 ;
 414 ; RV32I-LABEL: exp_f64:
 415 ; RV32I:       # %bb.0:
 416 ; RV32I-NEXT:    addi sp, sp, -16
 417 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 418 ; RV32I-NEXT:    call exp
 419 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 420 ; RV32I-NEXT:    addi sp, sp, 16
 421 ; RV32I-NEXT:    ret
 422 ;
 423 ; RV64I-LABEL: exp_f64:
 424 ; RV64I:       # %bb.0:
 425 ; RV64I-NEXT:    addi sp, sp, -16
 426 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 427 ; RV64I-NEXT:    call exp
 428 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 429 ; RV64I-NEXT:    addi sp, sp, 16
 430 ; RV64I-NEXT:    ret
 431   %1 = call double @llvm.exp.f64(double %a)
 432   ret double %1
 433 }
 434
 435 declare double @llvm.exp2.f64(double)
 436
 437 define double @exp2_f64(double %a) nounwind {
 438 ; CHECKIFD-LABEL: exp2_f64:
 439 ; CHECKIFD:       # %bb.0:
 440 ; CHECKIFD-NEXT:    tail exp2
 441 ;
 442 ; RV32IZFINXZDINX-LABEL: exp2_f64:
 443 ; RV32IZFINXZDINX:       # %bb.0:
 444 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 445 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 446 ; RV32IZFINXZDINX-NEXT:    call exp2
 447 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 448 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 449 ; RV32IZFINXZDINX-NEXT:    ret
 450 ;
 451 ; RV64IZFINXZDINX-LABEL: exp2_f64:
 452 ; RV64IZFINXZDINX:       # %bb.0:
 453 ; RV64IZFINXZDINX-NEXT:    tail exp2
 454 ;
 455 ; RV32I-LABEL: exp2_f64:
 456 ; RV32I:       # %bb.0:
 457 ; RV32I-NEXT:    addi sp, sp, -16
 458 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 459 ; RV32I-NEXT:    call exp2
 460 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 461 ; RV32I-NEXT:    addi sp, sp, 16
 462 ; RV32I-NEXT:    ret
 463 ;
 464 ; RV64I-LABEL: exp2_f64:
 465 ; RV64I:       # %bb.0:
 466 ; RV64I-NEXT:    addi sp, sp, -16
 467 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 468 ; RV64I-NEXT:    call exp2
 469 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 470 ; RV64I-NEXT:    addi sp, sp, 16
 471 ; RV64I-NEXT:    ret
 472   %1 = call double @llvm.exp2.f64(double %a)
 473   ret double %1
 474 }
 475
 476 declare double @llvm.log.f64(double)
 477
 478 define double @log_f64(double %a) nounwind {
 479 ; CHECKIFD-LABEL: log_f64:
 480 ; CHECKIFD:       # %bb.0:
 481 ; CHECKIFD-NEXT:    tail log
 482 ;
 483 ; RV32IZFINXZDINX-LABEL: log_f64:
 484 ; RV32IZFINXZDINX:       # %bb.0:
 485 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 486 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 487 ; RV32IZFINXZDINX-NEXT:    call log
 488 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 489 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 490 ; RV32IZFINXZDINX-NEXT:    ret
 491 ;
 492 ; RV64IZFINXZDINX-LABEL: log_f64:
 493 ; RV64IZFINXZDINX:       # %bb.0:
 494 ; RV64IZFINXZDINX-NEXT:    tail log
 495 ;
 496 ; RV32I-LABEL: log_f64:
 497 ; RV32I:       # %bb.0:
 498 ; RV32I-NEXT:    addi sp, sp, -16
 499 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 500 ; RV32I-NEXT:    call log
 501 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 502 ; RV32I-NEXT:    addi sp, sp, 16
 503 ; RV32I-NEXT:    ret
 504 ;
 505 ; RV64I-LABEL: log_f64:
 506 ; RV64I:       # %bb.0:
 507 ; RV64I-NEXT:    addi sp, sp, -16
 508 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 509 ; RV64I-NEXT:    call log
 510 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 511 ; RV64I-NEXT:    addi sp, sp, 16
 512 ; RV64I-NEXT:    ret
 513   %1 = call double @llvm.log.f64(double %a)
 514   ret double %1
 515 }
 516
 517 declare double @llvm.log10.f64(double)
 518
 519 define double @log10_f64(double %a) nounwind {
 520 ; CHECKIFD-LABEL: log10_f64:
 521 ; CHECKIFD:       # %bb.0:
 522 ; CHECKIFD-NEXT:    tail log10
 523 ;
 524 ; RV32IZFINXZDINX-LABEL: log10_f64:
 525 ; RV32IZFINXZDINX:       # %bb.0:
 526 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 527 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 528 ; RV32IZFINXZDINX-NEXT:    call log10
 529 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 530 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 531 ; RV32IZFINXZDINX-NEXT:    ret
 532 ;
 533 ; RV64IZFINXZDINX-LABEL: log10_f64:
 534 ; RV64IZFINXZDINX:       # %bb.0:
 535 ; RV64IZFINXZDINX-NEXT:    tail log10
 536 ;
 537 ; RV32I-LABEL: log10_f64:
 538 ; RV32I:       # %bb.0:
 539 ; RV32I-NEXT:    addi sp, sp, -16
 540 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 541 ; RV32I-NEXT:    call log10
 542 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 543 ; RV32I-NEXT:    addi sp, sp, 16
 544 ; RV32I-NEXT:    ret
 545 ;
 546 ; RV64I-LABEL: log10_f64:
 547 ; RV64I:       # %bb.0:
 548 ; RV64I-NEXT:    addi sp, sp, -16
 549 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 550 ; RV64I-NEXT:    call log10
 551 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 552 ; RV64I-NEXT:    addi sp, sp, 16
 553 ; RV64I-NEXT:    ret
 554   %1 = call double @llvm.log10.f64(double %a)
 555   ret double %1
 556 }
 557
 558 declare double @llvm.log2.f64(double)
 559
 560 define double @log2_f64(double %a) nounwind {
 561 ; CHECKIFD-LABEL: log2_f64:
 562 ; CHECKIFD:       # %bb.0:
 563 ; CHECKIFD-NEXT:    tail log2
 564 ;
 565 ; RV32IZFINXZDINX-LABEL: log2_f64:
 566 ; RV32IZFINXZDINX:       # %bb.0:
 567 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 568 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 569 ; RV32IZFINXZDINX-NEXT:    call log2
 570 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 571 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 572 ; RV32IZFINXZDINX-NEXT:    ret
 573 ;
 574 ; RV64IZFINXZDINX-LABEL: log2_f64:
 575 ; RV64IZFINXZDINX:       # %bb.0:
 576 ; RV64IZFINXZDINX-NEXT:    tail log2
 577 ;
 578 ; RV32I-LABEL: log2_f64:
 579 ; RV32I:       # %bb.0:
 580 ; RV32I-NEXT:    addi sp, sp, -16
 581 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 582 ; RV32I-NEXT:    call log2
 583 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 584 ; RV32I-NEXT:    addi sp, sp, 16
 585 ; RV32I-NEXT:    ret
 586 ;
 587 ; RV64I-LABEL: log2_f64:
 588 ; RV64I:       # %bb.0:
 589 ; RV64I-NEXT:    addi sp, sp, -16
 590 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 591 ; RV64I-NEXT:    call log2
 592 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 593 ; RV64I-NEXT:    addi sp, sp, 16
 594 ; RV64I-NEXT:    ret
 595   %1 = call double @llvm.log2.f64(double %a)
 596   ret double %1
 597 }
 598
 599 declare double @llvm.fma.f64(double, double, double)
 600
 601 define double @fma_f64(double %a, double %b, double %c) nounwind {
 602 ; CHECKIFD-LABEL: fma_f64:
 603 ; CHECKIFD:       # %bb.0:
 604 ; CHECKIFD-NEXT:    fmadd.d fa0, fa0, fa1, fa2
 605 ; CHECKIFD-NEXT:    ret
 606 ;
 607 ; RV32IZFINXZDINX-LABEL: fma_f64:
 608 ; RV32IZFINXZDINX:       # %bb.0:
 609 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 610 ; RV32IZFINXZDINX-NEXT:    sw a4, 8(sp)
 611 ; RV32IZFINXZDINX-NEXT:    sw a5, 12(sp)
 612 ; RV32IZFINXZDINX-NEXT:    lw a4, 8(sp)
 613 ; RV32IZFINXZDINX-NEXT:    lw a5, 12(sp)
 614 ; RV32IZFINXZDINX-NEXT:    sw a2, 8(sp)
 615 ; RV32IZFINXZDINX-NEXT:    sw a3, 12(sp)
 616 ; RV32IZFINXZDINX-NEXT:    lw a2, 8(sp)
 617 ; RV32IZFINXZDINX-NEXT:    lw a3, 12(sp)
 618 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 619 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 620 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 621 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 622 ; RV32IZFINXZDINX-NEXT:    fmadd.d a0, a0, a2, a4
 623 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 624 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 625 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 626 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 627 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 628 ; RV32IZFINXZDINX-NEXT:    ret
 629 ;
 630 ; RV64IZFINXZDINX-LABEL: fma_f64:
 631 ; RV64IZFINXZDINX:       # %bb.0:
 632 ; RV64IZFINXZDINX-NEXT:    fmadd.d a0, a0, a1, a2
 633 ; RV64IZFINXZDINX-NEXT:    ret
 634 ;
 635 ; RV32I-LABEL: fma_f64:
 636 ; RV32I:       # %bb.0:
 637 ; RV32I-NEXT:    addi sp, sp, -16
 638 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 639 ; RV32I-NEXT:    call fma
 640 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 641 ; RV32I-NEXT:    addi sp, sp, 16
 642 ; RV32I-NEXT:    ret
 643 ;
 644 ; RV64I-LABEL: fma_f64:
 645 ; RV64I:       # %bb.0:
 646 ; RV64I-NEXT:    addi sp, sp, -16
 647 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 648 ; RV64I-NEXT:    call fma
 649 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 650 ; RV64I-NEXT:    addi sp, sp, 16
 651 ; RV64I-NEXT:    ret
 652   %1 = call double @llvm.fma.f64(double %a, double %b, double %c)
 653   ret double %1
 654 }
 655
 656 declare double @llvm.fmuladd.f64(double, double, double)
 657
 658 define double @fmuladd_f64(double %a, double %b, double %c) nounwind {
 659 ; CHECKIFD-LABEL: fmuladd_f64:
 660 ; CHECKIFD:       # %bb.0:
 661 ; CHECKIFD-NEXT:    fmadd.d fa0, fa0, fa1, fa2
 662 ; CHECKIFD-NEXT:    ret
 663 ;
 664 ; RV32IZFINXZDINX-LABEL: fmuladd_f64:
 665 ; RV32IZFINXZDINX:       # %bb.0:
 666 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 667 ; RV32IZFINXZDINX-NEXT:    sw a4, 8(sp)
 668 ; RV32IZFINXZDINX-NEXT:    sw a5, 12(sp)
 669 ; RV32IZFINXZDINX-NEXT:    lw a4, 8(sp)
 670 ; RV32IZFINXZDINX-NEXT:    lw a5, 12(sp)
 671 ; RV32IZFINXZDINX-NEXT:    sw a2, 8(sp)
 672 ; RV32IZFINXZDINX-NEXT:    sw a3, 12(sp)
 673 ; RV32IZFINXZDINX-NEXT:    lw a2, 8(sp)
 674 ; RV32IZFINXZDINX-NEXT:    lw a3, 12(sp)
 675 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 676 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 677 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 678 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 679 ; RV32IZFINXZDINX-NEXT:    fmadd.d a0, a0, a2, a4
 680 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 681 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 682 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 683 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 684 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 685 ; RV32IZFINXZDINX-NEXT:    ret
 686 ;
 687 ; RV64IZFINXZDINX-LABEL: fmuladd_f64:
 688 ; RV64IZFINXZDINX:       # %bb.0:
 689 ; RV64IZFINXZDINX-NEXT:    fmadd.d a0, a0, a1, a2
 690 ; RV64IZFINXZDINX-NEXT:    ret
 691 ;
 692 ; RV32I-LABEL: fmuladd_f64:
 693 ; RV32I:       # %bb.0:
 694 ; RV32I-NEXT:    addi sp, sp, -16
 695 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 696 ; RV32I-NEXT:    sw s0, 8(sp) # 4-byte Folded Spill
 697 ; RV32I-NEXT:    sw s1, 4(sp) # 4-byte Folded Spill
 698 ; RV32I-NEXT:    mv s0, a5
 699 ; RV32I-NEXT:    mv s1, a4
 700 ; RV32I-NEXT:    call __muldf3
 701 ; RV32I-NEXT:    mv a2, s1
 702 ; RV32I-NEXT:    mv a3, s0
 703 ; RV32I-NEXT:    call __adddf3
 704 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 705 ; RV32I-NEXT:    lw s0, 8(sp) # 4-byte Folded Reload
 706 ; RV32I-NEXT:    lw s1, 4(sp) # 4-byte Folded Reload
 707 ; RV32I-NEXT:    addi sp, sp, 16
 708 ; RV32I-NEXT:    ret
 709 ;
 710 ; RV64I-LABEL: fmuladd_f64:
 711 ; RV64I:       # %bb.0:
 712 ; RV64I-NEXT:    addi sp, sp, -16
 713 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 714 ; RV64I-NEXT:    sd s0, 0(sp) # 8-byte Folded Spill
 715 ; RV64I-NEXT:    mv s0, a2
 716 ; RV64I-NEXT:    call __muldf3
 717 ; RV64I-NEXT:    mv a1, s0
 718 ; RV64I-NEXT:    call __adddf3
 719 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 720 ; RV64I-NEXT:    ld s0, 0(sp) # 8-byte Folded Reload
 721 ; RV64I-NEXT:    addi sp, sp, 16
 722 ; RV64I-NEXT:    ret
 723   %1 = call double @llvm.fmuladd.f64(double %a, double %b, double %c)
 724   ret double %1
 725 }
 726
 727 declare double @llvm.fabs.f64(double)
 728
 729 define double @fabs_f64(double %a) nounwind {
 730 ; CHECKIFD-LABEL: fabs_f64:
 731 ; CHECKIFD:       # %bb.0:
 732 ; CHECKIFD-NEXT:    fabs.d fa0, fa0
 733 ; CHECKIFD-NEXT:    ret
 734 ;
 735 ; RV32IZFINXZDINX-LABEL: fabs_f64:
 736 ; RV32IZFINXZDINX:       # %bb.0:
 737 ; RV32IZFINXZDINX-NEXT:    slli a1, a1, 1
 738 ; RV32IZFINXZDINX-NEXT:    srli a1, a1, 1
 739 ; RV32IZFINXZDINX-NEXT:    ret
 740 ;
 741 ; RV64IZFINXZDINX-LABEL: fabs_f64:
 742 ; RV64IZFINXZDINX:       # %bb.0:
 743 ; RV64IZFINXZDINX-NEXT:    slli a0, a0, 1
 744 ; RV64IZFINXZDINX-NEXT:    srli a0, a0, 1
 745 ; RV64IZFINXZDINX-NEXT:    ret
 746 ;
 747 ; RV32I-LABEL: fabs_f64:
 748 ; RV32I:       # %bb.0:
 749 ; RV32I-NEXT:    slli a1, a1, 1
 750 ; RV32I-NEXT:    srli a1, a1, 1
 751 ; RV32I-NEXT:    ret
 752 ;
 753 ; RV64I-LABEL: fabs_f64:
 754 ; RV64I:       # %bb.0:
 755 ; RV64I-NEXT:    slli a0, a0, 1
 756 ; RV64I-NEXT:    srli a0, a0, 1
 757 ; RV64I-NEXT:    ret
 758   %1 = call double @llvm.fabs.f64(double %a)
 759   ret double %1
 760 }
 761
 762 declare double @llvm.minnum.f64(double, double)
 763
 764 define double @minnum_f64(double %a, double %b) nounwind {
 765 ; CHECKIFD-LABEL: minnum_f64:
 766 ; CHECKIFD:       # %bb.0:
 767 ; CHECKIFD-NEXT:    fmin.d fa0, fa0, fa1
 768 ; CHECKIFD-NEXT:    ret
 769 ;
 770 ; RV32IZFINXZDINX-LABEL: minnum_f64:
 771 ; RV32IZFINXZDINX:       # %bb.0:
 772 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 773 ; RV32IZFINXZDINX-NEXT:    sw a2, 8(sp)
 774 ; RV32IZFINXZDINX-NEXT:    sw a3, 12(sp)
 775 ; RV32IZFINXZDINX-NEXT:    lw a2, 8(sp)
 776 ; RV32IZFINXZDINX-NEXT:    lw a3, 12(sp)
 777 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 778 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 779 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 780 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 781 ; RV32IZFINXZDINX-NEXT:    fmin.d a0, a0, a2
 782 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 783 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 784 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 785 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 786 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 787 ; RV32IZFINXZDINX-NEXT:    ret
 788 ;
 789 ; RV64IZFINXZDINX-LABEL: minnum_f64:
 790 ; RV64IZFINXZDINX:       # %bb.0:
 791 ; RV64IZFINXZDINX-NEXT:    fmin.d a0, a0, a1
 792 ; RV64IZFINXZDINX-NEXT:    ret
 793 ;
 794 ; RV32I-LABEL: minnum_f64:
 795 ; RV32I:       # %bb.0:
 796 ; RV32I-NEXT:    addi sp, sp, -16
 797 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 798 ; RV32I-NEXT:    call fmin
 799 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 800 ; RV32I-NEXT:    addi sp, sp, 16
 801 ; RV32I-NEXT:    ret
 802 ;
 803 ; RV64I-LABEL: minnum_f64:
 804 ; RV64I:       # %bb.0:
 805 ; RV64I-NEXT:    addi sp, sp, -16
 806 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 807 ; RV64I-NEXT:    call fmin
 808 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 809 ; RV64I-NEXT:    addi sp, sp, 16
 810 ; RV64I-NEXT:    ret
 811   %1 = call double @llvm.minnum.f64(double %a, double %b)
 812   ret double %1
 813 }
 814
 815 declare double @llvm.maxnum.f64(double, double)
 816
 817 define double @maxnum_f64(double %a, double %b) nounwind {
 818 ; CHECKIFD-LABEL: maxnum_f64:
 819 ; CHECKIFD:       # %bb.0:
 820 ; CHECKIFD-NEXT:    fmax.d fa0, fa0, fa1
 821 ; CHECKIFD-NEXT:    ret
 822 ;
 823 ; RV32IZFINXZDINX-LABEL: maxnum_f64:
 824 ; RV32IZFINXZDINX:       # %bb.0:
 825 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 826 ; RV32IZFINXZDINX-NEXT:    sw a2, 8(sp)
 827 ; RV32IZFINXZDINX-NEXT:    sw a3, 12(sp)
 828 ; RV32IZFINXZDINX-NEXT:    lw a2, 8(sp)
 829 ; RV32IZFINXZDINX-NEXT:    lw a3, 12(sp)
 830 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 831 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 832 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 833 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 834 ; RV32IZFINXZDINX-NEXT:    fmax.d a0, a0, a2
 835 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 836 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 837 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 838 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 839 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 840 ; RV32IZFINXZDINX-NEXT:    ret
 841 ;
 842 ; RV64IZFINXZDINX-LABEL: maxnum_f64:
 843 ; RV64IZFINXZDINX:       # %bb.0:
 844 ; RV64IZFINXZDINX-NEXT:    fmax.d a0, a0, a1
 845 ; RV64IZFINXZDINX-NEXT:    ret
 846 ;
 847 ; RV32I-LABEL: maxnum_f64:
 848 ; RV32I:       # %bb.0:
 849 ; RV32I-NEXT:    addi sp, sp, -16
 850 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 851 ; RV32I-NEXT:    call fmax
 852 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 853 ; RV32I-NEXT:    addi sp, sp, 16
 854 ; RV32I-NEXT:    ret
 855 ;
 856 ; RV64I-LABEL: maxnum_f64:
 857 ; RV64I:       # %bb.0:
 858 ; RV64I-NEXT:    addi sp, sp, -16
 859 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 860 ; RV64I-NEXT:    call fmax
 861 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 862 ; RV64I-NEXT:    addi sp, sp, 16
 863 ; RV64I-NEXT:    ret
 864   %1 = call double @llvm.maxnum.f64(double %a, double %b)
 865   ret double %1
 866 }
 867
 868 ; TODO: FMINNAN and FMAXNAN aren't handled in
 869 ; SelectionDAGLegalize::ExpandNode.
 870
 871 ; declare double @llvm.minimum.f64(double, double)
 872
 873 ; define double @fminimum_f64(double %a, double %b) nounwind {
 874 ;   %1 = call double @llvm.minimum.f64(double %a, double %b)
 875 ;   ret double %1
 876 ; }
 877
 878 ; declare double @llvm.maximum.f64(double, double)
 879
 880 ; define double @fmaximum_f64(double %a, double %b) nounwind {
 881 ;   %1 = call double @llvm.maximum.f64(double %a, double %b)
 882 ;   ret double %1
 883 ; }
 884
 885 declare double @llvm.copysign.f64(double, double)
 886
 887 define double @copysign_f64(double %a, double %b) nounwind {
 888 ; CHECKIFD-LABEL: copysign_f64:
 889 ; CHECKIFD:       # %bb.0:
 890 ; CHECKIFD-NEXT:    fsgnj.d fa0, fa0, fa1
 891 ; CHECKIFD-NEXT:    ret
 892 ;
 893 ; RV32IZFINXZDINX-LABEL: copysign_f64:
 894 ; RV32IZFINXZDINX:       # %bb.0:
 895 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 896 ; RV32IZFINXZDINX-NEXT:    sw a2, 8(sp)
 897 ; RV32IZFINXZDINX-NEXT:    sw a3, 12(sp)
 898 ; RV32IZFINXZDINX-NEXT:    lw a2, 8(sp)
 899 ; RV32IZFINXZDINX-NEXT:    lw a3, 12(sp)
 900 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 901 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 902 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 903 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 904 ; RV32IZFINXZDINX-NEXT:    fsgnj.d a0, a0, a2
 905 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
 906 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
 907 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 908 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
 909 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 910 ; RV32IZFINXZDINX-NEXT:    ret
 911 ;
 912 ; RV64IZFINXZDINX-LABEL: copysign_f64:
 913 ; RV64IZFINXZDINX:       # %bb.0:
 914 ; RV64IZFINXZDINX-NEXT:    fsgnj.d a0, a0, a1
 915 ; RV64IZFINXZDINX-NEXT:    ret
 916 ;
 917 ; RV32I-LABEL: copysign_f64:
 918 ; RV32I:       # %bb.0:
 919 ; RV32I-NEXT:    lui a2, 524288
 920 ; RV32I-NEXT:    and a2, a3, a2
 921 ; RV32I-NEXT:    slli a1, a1, 1
 922 ; RV32I-NEXT:    srli a1, a1, 1
 923 ; RV32I-NEXT:    or a1, a1, a2
 924 ; RV32I-NEXT:    ret
 925 ;
 926 ; RV64I-LABEL: copysign_f64:
 927 ; RV64I:       # %bb.0:
 928 ; RV64I-NEXT:    srli a1, a1, 63
 929 ; RV64I-NEXT:    slli a1, a1, 63
 930 ; RV64I-NEXT:    slli a0, a0, 1
 931 ; RV64I-NEXT:    srli a0, a0, 1
 932 ; RV64I-NEXT:    or a0, a0, a1
 933 ; RV64I-NEXT:    ret
 934   %1 = call double @llvm.copysign.f64(double %a, double %b)
 935   ret double %1
 936 }
 937
 938 declare double @llvm.floor.f64(double)
 939
 940 define double @floor_f64(double %a) nounwind {
 941 ; RV32IFD-LABEL: floor_f64:
 942 ; RV32IFD:       # %bb.0:
 943 ; RV32IFD-NEXT:    tail floor
 944 ;
 945 ; RV64IFD-LABEL: floor_f64:
 946 ; RV64IFD:       # %bb.0:
 947 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI17_0)
 948 ; RV64IFD-NEXT:    fld fa5, %lo(.LCPI17_0)(a0)
 949 ; RV64IFD-NEXT:    fabs.d fa4, fa0
 950 ; RV64IFD-NEXT:    flt.d a0, fa4, fa5
 951 ; RV64IFD-NEXT:    beqz a0, .LBB17_2
 952 ; RV64IFD-NEXT:  # %bb.1:
 953 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0, rdn
 954 ; RV64IFD-NEXT:    fcvt.d.l fa5, a0, rdn
 955 ; RV64IFD-NEXT:    fsgnj.d fa0, fa5, fa0
 956 ; RV64IFD-NEXT:  .LBB17_2:
 957 ; RV64IFD-NEXT:    ret
 958 ;
 959 ; RV32IZFINXZDINX-LABEL: floor_f64:
 960 ; RV32IZFINXZDINX:       # %bb.0:
 961 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 962 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 963 ; RV32IZFINXZDINX-NEXT:    call floor
 964 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 965 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 966 ; RV32IZFINXZDINX-NEXT:    ret
 967 ;
 968 ; RV64IZFINXZDINX-LABEL: floor_f64:
 969 ; RV64IZFINXZDINX:       # %bb.0:
 970 ; RV64IZFINXZDINX-NEXT:    lui a1, %hi(.LCPI17_0)
 971 ; RV64IZFINXZDINX-NEXT:    ld a1, %lo(.LCPI17_0)(a1)
 972 ; RV64IZFINXZDINX-NEXT:    fabs.d a2, a0
 973 ; RV64IZFINXZDINX-NEXT:    flt.d a1, a2, a1
 974 ; RV64IZFINXZDINX-NEXT:    beqz a1, .LBB17_2
 975 ; RV64IZFINXZDINX-NEXT:  # %bb.1:
 976 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a1, a0, rdn
 977 ; RV64IZFINXZDINX-NEXT:    fcvt.d.l a1, a1, rdn
 978 ; RV64IZFINXZDINX-NEXT:    fsgnj.d a0, a1, a0
 979 ; RV64IZFINXZDINX-NEXT:  .LBB17_2:
 980 ; RV64IZFINXZDINX-NEXT:    ret
 981 ;
 982 ; RV32I-LABEL: floor_f64:
 983 ; RV32I:       # %bb.0:
 984 ; RV32I-NEXT:    addi sp, sp, -16
 985 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 986 ; RV32I-NEXT:    call floor
 987 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 988 ; RV32I-NEXT:    addi sp, sp, 16
 989 ; RV32I-NEXT:    ret
 990 ;
 991 ; RV64I-LABEL: floor_f64:
 992 ; RV64I:       # %bb.0:
 993 ; RV64I-NEXT:    addi sp, sp, -16
 994 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 995 ; RV64I-NEXT:    call floor
 996 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 997 ; RV64I-NEXT:    addi sp, sp, 16
 998 ; RV64I-NEXT:    ret
 999   %1 = call double @llvm.floor.f64(double %a)
1000   ret double %1
1001 }
1002
1003 declare double @llvm.ceil.f64(double)
1004
1005 define double @ceil_f64(double %a) nounwind {
1006 ; RV32IFD-LABEL: ceil_f64:
1007 ; RV32IFD:       # %bb.0:
1008 ; RV32IFD-NEXT:    tail ceil
1009 ;
1010 ; RV64IFD-LABEL: ceil_f64:
1011 ; RV64IFD:       # %bb.0:
1012 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI18_0)
1013 ; RV64IFD-NEXT:    fld fa5, %lo(.LCPI18_0)(a0)
1014 ; RV64IFD-NEXT:    fabs.d fa4, fa0
1015 ; RV64IFD-NEXT:    flt.d a0, fa4, fa5
1016 ; RV64IFD-NEXT:    beqz a0, .LBB18_2
1017 ; RV64IFD-NEXT:  # %bb.1:
1018 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0, rup
1019 ; RV64IFD-NEXT:    fcvt.d.l fa5, a0, rup
1020 ; RV64IFD-NEXT:    fsgnj.d fa0, fa5, fa0
1021 ; RV64IFD-NEXT:  .LBB18_2:
1022 ; RV64IFD-NEXT:    ret
1023 ;
1024 ; RV32IZFINXZDINX-LABEL: ceil_f64:
1025 ; RV32IZFINXZDINX:       # %bb.0:
1026 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1027 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1028 ; RV32IZFINXZDINX-NEXT:    call ceil
1029 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1030 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1031 ; RV32IZFINXZDINX-NEXT:    ret
1032 ;
1033 ; RV64IZFINXZDINX-LABEL: ceil_f64:
1034 ; RV64IZFINXZDINX:       # %bb.0:
1035 ; RV64IZFINXZDINX-NEXT:    lui a1, %hi(.LCPI18_0)
1036 ; RV64IZFINXZDINX-NEXT:    ld a1, %lo(.LCPI18_0)(a1)
1037 ; RV64IZFINXZDINX-NEXT:    fabs.d a2, a0
1038 ; RV64IZFINXZDINX-NEXT:    flt.d a1, a2, a1
1039 ; RV64IZFINXZDINX-NEXT:    beqz a1, .LBB18_2
1040 ; RV64IZFINXZDINX-NEXT:  # %bb.1:
1041 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a1, a0, rup
1042 ; RV64IZFINXZDINX-NEXT:    fcvt.d.l a1, a1, rup
1043 ; RV64IZFINXZDINX-NEXT:    fsgnj.d a0, a1, a0
1044 ; RV64IZFINXZDINX-NEXT:  .LBB18_2:
1045 ; RV64IZFINXZDINX-NEXT:    ret
1046 ;
1047 ; RV32I-LABEL: ceil_f64:
1048 ; RV32I:       # %bb.0:
1049 ; RV32I-NEXT:    addi sp, sp, -16
1050 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1051 ; RV32I-NEXT:    call ceil
1052 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1053 ; RV32I-NEXT:    addi sp, sp, 16
1054 ; RV32I-NEXT:    ret
1055 ;
1056 ; RV64I-LABEL: ceil_f64:
1057 ; RV64I:       # %bb.0:
1058 ; RV64I-NEXT:    addi sp, sp, -16
1059 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1060 ; RV64I-NEXT:    call ceil
1061 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1062 ; RV64I-NEXT:    addi sp, sp, 16
1063 ; RV64I-NEXT:    ret
1064   %1 = call double @llvm.ceil.f64(double %a)
1065   ret double %1
1066 }
1067
1068 declare double @llvm.trunc.f64(double)
1069
1070 define double @trunc_f64(double %a) nounwind {
1071 ; RV32IFD-LABEL: trunc_f64:
1072 ; RV32IFD:       # %bb.0:
1073 ; RV32IFD-NEXT:    tail trunc
1074 ;
1075 ; RV64IFD-LABEL: trunc_f64:
1076 ; RV64IFD:       # %bb.0:
1077 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI19_0)
1078 ; RV64IFD-NEXT:    fld fa5, %lo(.LCPI19_0)(a0)
1079 ; RV64IFD-NEXT:    fabs.d fa4, fa0
1080 ; RV64IFD-NEXT:    flt.d a0, fa4, fa5
1081 ; RV64IFD-NEXT:    beqz a0, .LBB19_2
1082 ; RV64IFD-NEXT:  # %bb.1:
1083 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0, rtz
1084 ; RV64IFD-NEXT:    fcvt.d.l fa5, a0, rtz
1085 ; RV64IFD-NEXT:    fsgnj.d fa0, fa5, fa0
1086 ; RV64IFD-NEXT:  .LBB19_2:
1087 ; RV64IFD-NEXT:    ret
1088 ;
1089 ; RV32IZFINXZDINX-LABEL: trunc_f64:
1090 ; RV32IZFINXZDINX:       # %bb.0:
1091 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1092 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1093 ; RV32IZFINXZDINX-NEXT:    call trunc
1094 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1095 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1096 ; RV32IZFINXZDINX-NEXT:    ret
1097 ;
1098 ; RV64IZFINXZDINX-LABEL: trunc_f64:
1099 ; RV64IZFINXZDINX:       # %bb.0:
1100 ; RV64IZFINXZDINX-NEXT:    lui a1, %hi(.LCPI19_0)
1101 ; RV64IZFINXZDINX-NEXT:    ld a1, %lo(.LCPI19_0)(a1)
1102 ; RV64IZFINXZDINX-NEXT:    fabs.d a2, a0
1103 ; RV64IZFINXZDINX-NEXT:    flt.d a1, a2, a1
1104 ; RV64IZFINXZDINX-NEXT:    beqz a1, .LBB19_2
1105 ; RV64IZFINXZDINX-NEXT:  # %bb.1:
1106 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a1, a0, rtz
1107 ; RV64IZFINXZDINX-NEXT:    fcvt.d.l a1, a1, rtz
1108 ; RV64IZFINXZDINX-NEXT:    fsgnj.d a0, a1, a0
1109 ; RV64IZFINXZDINX-NEXT:  .LBB19_2:
1110 ; RV64IZFINXZDINX-NEXT:    ret
1111 ;
1112 ; RV32I-LABEL: trunc_f64:
1113 ; RV32I:       # %bb.0:
1114 ; RV32I-NEXT:    addi sp, sp, -16
1115 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1116 ; RV32I-NEXT:    call trunc
1117 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1118 ; RV32I-NEXT:    addi sp, sp, 16
1119 ; RV32I-NEXT:    ret
1120 ;
1121 ; RV64I-LABEL: trunc_f64:
1122 ; RV64I:       # %bb.0:
1123 ; RV64I-NEXT:    addi sp, sp, -16
1124 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1125 ; RV64I-NEXT:    call trunc
1126 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1127 ; RV64I-NEXT:    addi sp, sp, 16
1128 ; RV64I-NEXT:    ret
1129   %1 = call double @llvm.trunc.f64(double %a)
1130   ret double %1
1131 }
1132
1133 declare double @llvm.rint.f64(double)
1134
1135 define double @rint_f64(double %a) nounwind {
1136 ; RV32IFD-LABEL: rint_f64:
1137 ; RV32IFD:       # %bb.0:
1138 ; RV32IFD-NEXT:    tail rint
1139 ;
1140 ; RV64IFD-LABEL: rint_f64:
1141 ; RV64IFD:       # %bb.0:
1142 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI20_0)
1143 ; RV64IFD-NEXT:    fld fa5, %lo(.LCPI20_0)(a0)
1144 ; RV64IFD-NEXT:    fabs.d fa4, fa0
1145 ; RV64IFD-NEXT:    flt.d a0, fa4, fa5
1146 ; RV64IFD-NEXT:    beqz a0, .LBB20_2
1147 ; RV64IFD-NEXT:  # %bb.1:
1148 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0
1149 ; RV64IFD-NEXT:    fcvt.d.l fa5, a0
1150 ; RV64IFD-NEXT:    fsgnj.d fa0, fa5, fa0
1151 ; RV64IFD-NEXT:  .LBB20_2:
1152 ; RV64IFD-NEXT:    ret
1153 ;
1154 ; RV32IZFINXZDINX-LABEL: rint_f64:
1155 ; RV32IZFINXZDINX:       # %bb.0:
1156 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1157 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1158 ; RV32IZFINXZDINX-NEXT:    call rint
1159 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1160 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1161 ; RV32IZFINXZDINX-NEXT:    ret
1162 ;
1163 ; RV64IZFINXZDINX-LABEL: rint_f64:
1164 ; RV64IZFINXZDINX:       # %bb.0:
1165 ; RV64IZFINXZDINX-NEXT:    lui a1, %hi(.LCPI20_0)
1166 ; RV64IZFINXZDINX-NEXT:    ld a1, %lo(.LCPI20_0)(a1)
1167 ; RV64IZFINXZDINX-NEXT:    fabs.d a2, a0
1168 ; RV64IZFINXZDINX-NEXT:    flt.d a1, a2, a1
1169 ; RV64IZFINXZDINX-NEXT:    beqz a1, .LBB20_2
1170 ; RV64IZFINXZDINX-NEXT:  # %bb.1:
1171 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a1, a0
1172 ; RV64IZFINXZDINX-NEXT:    fcvt.d.l a1, a1
1173 ; RV64IZFINXZDINX-NEXT:    fsgnj.d a0, a1, a0
1174 ; RV64IZFINXZDINX-NEXT:  .LBB20_2:
1175 ; RV64IZFINXZDINX-NEXT:    ret
1176 ;
1177 ; RV32I-LABEL: rint_f64:
1178 ; RV32I:       # %bb.0:
1179 ; RV32I-NEXT:    addi sp, sp, -16
1180 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1181 ; RV32I-NEXT:    call rint
1182 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1183 ; RV32I-NEXT:    addi sp, sp, 16
1184 ; RV32I-NEXT:    ret
1185 ;
1186 ; RV64I-LABEL: rint_f64:
1187 ; RV64I:       # %bb.0:
1188 ; RV64I-NEXT:    addi sp, sp, -16
1189 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1190 ; RV64I-NEXT:    call rint
1191 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1192 ; RV64I-NEXT:    addi sp, sp, 16
1193 ; RV64I-NEXT:    ret
1194   %1 = call double @llvm.rint.f64(double %a)
1195   ret double %1
1196 }
1197
1198 declare double @llvm.nearbyint.f64(double)
1199
1200 define double @nearbyint_f64(double %a) nounwind {
1201 ; CHECKIFD-LABEL: nearbyint_f64:
1202 ; CHECKIFD:       # %bb.0:
1203 ; CHECKIFD-NEXT:    tail nearbyint
1204 ;
1205 ; RV32IZFINXZDINX-LABEL: nearbyint_f64:
1206 ; RV32IZFINXZDINX:       # %bb.0:
1207 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1208 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1209 ; RV32IZFINXZDINX-NEXT:    call nearbyint
1210 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1211 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1212 ; RV32IZFINXZDINX-NEXT:    ret
1213 ;
1214 ; RV64IZFINXZDINX-LABEL: nearbyint_f64:
1215 ; RV64IZFINXZDINX:       # %bb.0:
1216 ; RV64IZFINXZDINX-NEXT:    tail nearbyint
1217 ;
1218 ; RV32I-LABEL: nearbyint_f64:
1219 ; RV32I:       # %bb.0:
1220 ; RV32I-NEXT:    addi sp, sp, -16
1221 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1222 ; RV32I-NEXT:    call nearbyint
1223 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1224 ; RV32I-NEXT:    addi sp, sp, 16
1225 ; RV32I-NEXT:    ret
1226 ;
1227 ; RV64I-LABEL: nearbyint_f64:
1228 ; RV64I:       # %bb.0:
1229 ; RV64I-NEXT:    addi sp, sp, -16
1230 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1231 ; RV64I-NEXT:    call nearbyint
1232 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1233 ; RV64I-NEXT:    addi sp, sp, 16
1234 ; RV64I-NEXT:    ret
1235   %1 = call double @llvm.nearbyint.f64(double %a)
1236   ret double %1
1237 }
1238
1239 declare double @llvm.round.f64(double)
1240
1241 define double @round_f64(double %a) nounwind {
1242 ; RV32IFD-LABEL: round_f64:
1243 ; RV32IFD:       # %bb.0:
1244 ; RV32IFD-NEXT:    tail round
1245 ;
1246 ; RV64IFD-LABEL: round_f64:
1247 ; RV64IFD:       # %bb.0:
1248 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI22_0)
1249 ; RV64IFD-NEXT:    fld fa5, %lo(.LCPI22_0)(a0)
1250 ; RV64IFD-NEXT:    fabs.d fa4, fa0
1251 ; RV64IFD-NEXT:    flt.d a0, fa4, fa5
1252 ; RV64IFD-NEXT:    beqz a0, .LBB22_2
1253 ; RV64IFD-NEXT:  # %bb.1:
1254 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0, rmm
1255 ; RV64IFD-NEXT:    fcvt.d.l fa5, a0, rmm
1256 ; RV64IFD-NEXT:    fsgnj.d fa0, fa5, fa0
1257 ; RV64IFD-NEXT:  .LBB22_2:
1258 ; RV64IFD-NEXT:    ret
1259 ;
1260 ; RV32IZFINXZDINX-LABEL: round_f64:
1261 ; RV32IZFINXZDINX:       # %bb.0:
1262 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1263 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1264 ; RV32IZFINXZDINX-NEXT:    call round
1265 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1266 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1267 ; RV32IZFINXZDINX-NEXT:    ret
1268 ;
1269 ; RV64IZFINXZDINX-LABEL: round_f64:
1270 ; RV64IZFINXZDINX:       # %bb.0:
1271 ; RV64IZFINXZDINX-NEXT:    lui a1, %hi(.LCPI22_0)
1272 ; RV64IZFINXZDINX-NEXT:    ld a1, %lo(.LCPI22_0)(a1)
1273 ; RV64IZFINXZDINX-NEXT:    fabs.d a2, a0
1274 ; RV64IZFINXZDINX-NEXT:    flt.d a1, a2, a1
1275 ; RV64IZFINXZDINX-NEXT:    beqz a1, .LBB22_2
1276 ; RV64IZFINXZDINX-NEXT:  # %bb.1:
1277 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a1, a0, rmm
1278 ; RV64IZFINXZDINX-NEXT:    fcvt.d.l a1, a1, rmm
1279 ; RV64IZFINXZDINX-NEXT:    fsgnj.d a0, a1, a0
1280 ; RV64IZFINXZDINX-NEXT:  .LBB22_2:
1281 ; RV64IZFINXZDINX-NEXT:    ret
1282 ;
1283 ; RV32I-LABEL: round_f64:
1284 ; RV32I:       # %bb.0:
1285 ; RV32I-NEXT:    addi sp, sp, -16
1286 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1287 ; RV32I-NEXT:    call round
1288 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1289 ; RV32I-NEXT:    addi sp, sp, 16
1290 ; RV32I-NEXT:    ret
1291 ;
1292 ; RV64I-LABEL: round_f64:
1293 ; RV64I:       # %bb.0:
1294 ; RV64I-NEXT:    addi sp, sp, -16
1295 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1296 ; RV64I-NEXT:    call round
1297 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1298 ; RV64I-NEXT:    addi sp, sp, 16
1299 ; RV64I-NEXT:    ret
1300   %1 = call double @llvm.round.f64(double %a)
1301   ret double %1
1302 }
1303
1304 declare double @llvm.roundeven.f64(double)
1305
1306 define double @roundeven_f64(double %a) nounwind {
1307 ; RV32IFD-LABEL: roundeven_f64:
1308 ; RV32IFD:       # %bb.0:
1309 ; RV32IFD-NEXT:    tail roundeven
1310 ;
1311 ; RV64IFD-LABEL: roundeven_f64:
1312 ; RV64IFD:       # %bb.0:
1313 ; RV64IFD-NEXT:    lui a0, %hi(.LCPI23_0)
1314 ; RV64IFD-NEXT:    fld fa5, %lo(.LCPI23_0)(a0)
1315 ; RV64IFD-NEXT:    fabs.d fa4, fa0
1316 ; RV64IFD-NEXT:    flt.d a0, fa4, fa5
1317 ; RV64IFD-NEXT:    beqz a0, .LBB23_2
1318 ; RV64IFD-NEXT:  # %bb.1:
1319 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0, rne
1320 ; RV64IFD-NEXT:    fcvt.d.l fa5, a0, rne
1321 ; RV64IFD-NEXT:    fsgnj.d fa0, fa5, fa0
1322 ; RV64IFD-NEXT:  .LBB23_2:
1323 ; RV64IFD-NEXT:    ret
1324 ;
1325 ; RV32IZFINXZDINX-LABEL: roundeven_f64:
1326 ; RV32IZFINXZDINX:       # %bb.0:
1327 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1328 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1329 ; RV32IZFINXZDINX-NEXT:    call roundeven
1330 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1331 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1332 ; RV32IZFINXZDINX-NEXT:    ret
1333 ;
1334 ; RV64IZFINXZDINX-LABEL: roundeven_f64:
1335 ; RV64IZFINXZDINX:       # %bb.0:
1336 ; RV64IZFINXZDINX-NEXT:    lui a1, %hi(.LCPI23_0)
1337 ; RV64IZFINXZDINX-NEXT:    ld a1, %lo(.LCPI23_0)(a1)
1338 ; RV64IZFINXZDINX-NEXT:    fabs.d a2, a0
1339 ; RV64IZFINXZDINX-NEXT:    flt.d a1, a2, a1
1340 ; RV64IZFINXZDINX-NEXT:    beqz a1, .LBB23_2
1341 ; RV64IZFINXZDINX-NEXT:  # %bb.1:
1342 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a1, a0, rne
1343 ; RV64IZFINXZDINX-NEXT:    fcvt.d.l a1, a1, rne
1344 ; RV64IZFINXZDINX-NEXT:    fsgnj.d a0, a1, a0
1345 ; RV64IZFINXZDINX-NEXT:  .LBB23_2:
1346 ; RV64IZFINXZDINX-NEXT:    ret
1347 ;
1348 ; RV32I-LABEL: roundeven_f64:
1349 ; RV32I:       # %bb.0:
1350 ; RV32I-NEXT:    addi sp, sp, -16
1351 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1352 ; RV32I-NEXT:    call roundeven
1353 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1354 ; RV32I-NEXT:    addi sp, sp, 16
1355 ; RV32I-NEXT:    ret
1356 ;
1357 ; RV64I-LABEL: roundeven_f64:
1358 ; RV64I:       # %bb.0:
1359 ; RV64I-NEXT:    addi sp, sp, -16
1360 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1361 ; RV64I-NEXT:    call roundeven
1362 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1363 ; RV64I-NEXT:    addi sp, sp, 16
1364 ; RV64I-NEXT:    ret
1365   %1 = call double @llvm.roundeven.f64(double %a)
1366   ret double %1
1367 }
1368
1369 declare iXLen @llvm.lrint.iXLen.f64(double)
1370
1371 define iXLen @lrint_f64(double %a) nounwind {
1372 ; RV32IFD-LABEL: lrint_f64:
1373 ; RV32IFD:       # %bb.0:
1374 ; RV32IFD-NEXT:    fcvt.w.d a0, fa0
1375 ; RV32IFD-NEXT:    ret
1376 ;
1377 ; RV64IFD-LABEL: lrint_f64:
1378 ; RV64IFD:       # %bb.0:
1379 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0
1380 ; RV64IFD-NEXT:    ret
1381 ;
1382 ; RV32IZFINXZDINX-LABEL: lrint_f64:
1383 ; RV32IZFINXZDINX:       # %bb.0:
1384 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1385 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
1386 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
1387 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
1388 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
1389 ; RV32IZFINXZDINX-NEXT:    fcvt.w.d a0, a0
1390 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1391 ; RV32IZFINXZDINX-NEXT:    ret
1392 ;
1393 ; RV64IZFINXZDINX-LABEL: lrint_f64:
1394 ; RV64IZFINXZDINX:       # %bb.0:
1395 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a0, a0
1396 ; RV64IZFINXZDINX-NEXT:    ret
1397 ;
1398 ; RV32I-LABEL: lrint_f64:
1399 ; RV32I:       # %bb.0:
1400 ; RV32I-NEXT:    addi sp, sp, -16
1401 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1402 ; RV32I-NEXT:    call lrint
1403 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1404 ; RV32I-NEXT:    addi sp, sp, 16
1405 ; RV32I-NEXT:    ret
1406 ;
1407 ; RV64I-LABEL: lrint_f64:
1408 ; RV64I:       # %bb.0:
1409 ; RV64I-NEXT:    addi sp, sp, -16
1410 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1411 ; RV64I-NEXT:    call lrint
1412 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1413 ; RV64I-NEXT:    addi sp, sp, 16
1414 ; RV64I-NEXT:    ret
1415   %1 = call iXLen @llvm.lrint.iXLen.f64(double %a)
1416   ret iXLen %1
1417 }
1418
1419 declare i32 @llvm.lround.i32.f64(double)
1420 declare i64 @llvm.lround.i64.f64(double)
1421
1422 define iXLen @lround_f64(double %a) nounwind {
1423 ; RV32IFD-LABEL: lround_f64:
1424 ; RV32IFD:       # %bb.0:
1425 ; RV32IFD-NEXT:    fcvt.w.d a0, fa0, rmm
1426 ; RV32IFD-NEXT:    ret
1427 ;
1428 ; RV64IFD-LABEL: lround_f64:
1429 ; RV64IFD:       # %bb.0:
1430 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0, rmm
1431 ; RV64IFD-NEXT:    ret
1432 ;
1433 ; RV32IZFINXZDINX-LABEL: lround_f64:
1434 ; RV32IZFINXZDINX:       # %bb.0:
1435 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1436 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
1437 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
1438 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
1439 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
1440 ; RV32IZFINXZDINX-NEXT:    fcvt.w.d a0, a0, rmm
1441 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1442 ; RV32IZFINXZDINX-NEXT:    ret
1443 ;
1444 ; RV64IZFINXZDINX-LABEL: lround_f64:
1445 ; RV64IZFINXZDINX:       # %bb.0:
1446 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a0, a0, rmm
1447 ; RV64IZFINXZDINX-NEXT:    ret
1448 ;
1449 ; RV32I-LABEL: lround_f64:
1450 ; RV32I:       # %bb.0:
1451 ; RV32I-NEXT:    addi sp, sp, -16
1452 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1453 ; RV32I-NEXT:    call lround
1454 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1455 ; RV32I-NEXT:    addi sp, sp, 16
1456 ; RV32I-NEXT:    ret
1457 ;
1458 ; RV64I-LABEL: lround_f64:
1459 ; RV64I:       # %bb.0:
1460 ; RV64I-NEXT:    addi sp, sp, -16
1461 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1462 ; RV64I-NEXT:    call lround
1463 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1464 ; RV64I-NEXT:    addi sp, sp, 16
1465 ; RV64I-NEXT:    ret
1466   %1 = call iXLen @llvm.lround.iXLen.f64(double %a)
1467   ret iXLen %1
1468 }
1469
1470 define i32 @lround_i32_f64(double %a) nounwind {
1471 ; CHECKIFD-LABEL: lround_i32_f64:
1472 ; CHECKIFD:       # %bb.0:
1473 ; CHECKIFD-NEXT:    fcvt.w.d a0, fa0, rmm
1474 ; CHECKIFD-NEXT:    ret
1475 ;
1476 ; RV32IZFINXZDINX-LABEL: lround_i32_f64:
1477 ; RV32IZFINXZDINX:       # %bb.0:
1478 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1479 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
1480 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
1481 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
1482 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
1483 ; RV32IZFINXZDINX-NEXT:    fcvt.w.d a0, a0, rmm
1484 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1485 ; RV32IZFINXZDINX-NEXT:    ret
1486 ;
1487 ; RV64IZFINXZDINX-LABEL: lround_i32_f64:
1488 ; RV64IZFINXZDINX:       # %bb.0:
1489 ; RV64IZFINXZDINX-NEXT:    fcvt.w.d a0, a0, rmm
1490 ; RV64IZFINXZDINX-NEXT:    ret
1491 ;
1492 ; RV32I-LABEL: lround_i32_f64:
1493 ; RV32I:       # %bb.0:
1494 ; RV32I-NEXT:    addi sp, sp, -16
1495 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1496 ; RV32I-NEXT:    call lround
1497 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1498 ; RV32I-NEXT:    addi sp, sp, 16
1499 ; RV32I-NEXT:    ret
1500 ;
1501 ; RV64I-LABEL: lround_i32_f64:
1502 ; RV64I:       # %bb.0:
1503 ; RV64I-NEXT:    addi sp, sp, -16
1504 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1505 ; RV64I-NEXT:    call lround
1506 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1507 ; RV64I-NEXT:    addi sp, sp, 16
1508 ; RV64I-NEXT:    ret
1509   %1 = call i32 @llvm.lround.i32.f64(double %a)
1510   ret i32 %1
1511 }
1512
1513 declare i64 @llvm.llrint.i64.f64(double)
1514
1515 define i64 @llrint_f64(double %a) nounwind {
1516 ; RV32IFD-LABEL: llrint_f64:
1517 ; RV32IFD:       # %bb.0:
1518 ; RV32IFD-NEXT:    addi sp, sp, -16
1519 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1520 ; RV32IFD-NEXT:    call llrint
1521 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1522 ; RV32IFD-NEXT:    addi sp, sp, 16
1523 ; RV32IFD-NEXT:    ret
1524 ;
1525 ; RV64IFD-LABEL: llrint_f64:
1526 ; RV64IFD:       # %bb.0:
1527 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0
1528 ; RV64IFD-NEXT:    ret
1529 ;
1530 ; RV32IZFINXZDINX-LABEL: llrint_f64:
1531 ; RV32IZFINXZDINX:       # %bb.0:
1532 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1533 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1534 ; RV32IZFINXZDINX-NEXT:    call llrint
1535 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1536 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1537 ; RV32IZFINXZDINX-NEXT:    ret
1538 ;
1539 ; RV64IZFINXZDINX-LABEL: llrint_f64:
1540 ; RV64IZFINXZDINX:       # %bb.0:
1541 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a0, a0
1542 ; RV64IZFINXZDINX-NEXT:    ret
1543 ;
1544 ; RV32I-LABEL: llrint_f64:
1545 ; RV32I:       # %bb.0:
1546 ; RV32I-NEXT:    addi sp, sp, -16
1547 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1548 ; RV32I-NEXT:    call llrint
1549 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1550 ; RV32I-NEXT:    addi sp, sp, 16
1551 ; RV32I-NEXT:    ret
1552 ;
1553 ; RV64I-LABEL: llrint_f64:
1554 ; RV64I:       # %bb.0:
1555 ; RV64I-NEXT:    addi sp, sp, -16
1556 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1557 ; RV64I-NEXT:    call llrint
1558 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1559 ; RV64I-NEXT:    addi sp, sp, 16
1560 ; RV64I-NEXT:    ret
1561   %1 = call i64 @llvm.llrint.i64.f64(double %a)
1562   ret i64 %1
1563 }
1564
1565 declare i64 @llvm.llround.i64.f64(double)
1566
1567 define i64 @llround_f64(double %a) nounwind {
1568 ; RV32IFD-LABEL: llround_f64:
1569 ; RV32IFD:       # %bb.0:
1570 ; RV32IFD-NEXT:    addi sp, sp, -16
1571 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1572 ; RV32IFD-NEXT:    call llround
1573 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1574 ; RV32IFD-NEXT:    addi sp, sp, 16
1575 ; RV32IFD-NEXT:    ret
1576 ;
1577 ; RV64IFD-LABEL: llround_f64:
1578 ; RV64IFD:       # %bb.0:
1579 ; RV64IFD-NEXT:    fcvt.l.d a0, fa0, rmm
1580 ; RV64IFD-NEXT:    ret
1581 ;
1582 ; RV32IZFINXZDINX-LABEL: llround_f64:
1583 ; RV32IZFINXZDINX:       # %bb.0:
1584 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1585 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1586 ; RV32IZFINXZDINX-NEXT:    call llround
1587 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1588 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1589 ; RV32IZFINXZDINX-NEXT:    ret
1590 ;
1591 ; RV64IZFINXZDINX-LABEL: llround_f64:
1592 ; RV64IZFINXZDINX:       # %bb.0:
1593 ; RV64IZFINXZDINX-NEXT:    fcvt.l.d a0, a0, rmm
1594 ; RV64IZFINXZDINX-NEXT:    ret
1595 ;
1596 ; RV32I-LABEL: llround_f64:
1597 ; RV32I:       # %bb.0:
1598 ; RV32I-NEXT:    addi sp, sp, -16
1599 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1600 ; RV32I-NEXT:    call llround
1601 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1602 ; RV32I-NEXT:    addi sp, sp, 16
1603 ; RV32I-NEXT:    ret
1604 ;
1605 ; RV64I-LABEL: llround_f64:
1606 ; RV64I:       # %bb.0:
1607 ; RV64I-NEXT:    addi sp, sp, -16
1608 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1609 ; RV64I-NEXT:    call llround
1610 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1611 ; RV64I-NEXT:    addi sp, sp, 16
1612 ; RV64I-NEXT:    ret
1613   %1 = call i64 @llvm.llround.i64.f64(double %a)
1614   ret i64 %1
1615 }
1616
1617 declare i1 @llvm.is.fpclass.f64(double, i32)
1618 define i1 @isnan_d_fpclass(double %x) {
1619 ; CHECKIFD-LABEL: isnan_d_fpclass:
1620 ; CHECKIFD:       # %bb.0:
1621 ; CHECKIFD-NEXT:    fclass.d a0, fa0
1622 ; CHECKIFD-NEXT:    andi a0, a0, 768
1623 ; CHECKIFD-NEXT:    snez a0, a0
1624 ; CHECKIFD-NEXT:    ret
1625 ;
1626 ; RV32IZFINXZDINX-LABEL: isnan_d_fpclass:
1627 ; RV32IZFINXZDINX:       # %bb.0:
1628 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1629 ; RV32IZFINXZDINX-NEXT:    .cfi_def_cfa_offset 16
1630 ; RV32IZFINXZDINX-NEXT:    sw a0, 8(sp)
1631 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
1632 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
1633 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(sp)
1634 ; RV32IZFINXZDINX-NEXT:    fclass.d a0, a0
1635 ; RV32IZFINXZDINX-NEXT:    andi a0, a0, 768
1636 ; RV32IZFINXZDINX-NEXT:    snez a0, a0
1637 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1638 ; RV32IZFINXZDINX-NEXT:    ret
1639 ;
1640 ; RV64IZFINXZDINX-LABEL: isnan_d_fpclass:
1641 ; RV64IZFINXZDINX:       # %bb.0:
1642 ; RV64IZFINXZDINX-NEXT:    fclass.d a0, a0
1643 ; RV64IZFINXZDINX-NEXT:    andi a0, a0, 768
1644 ; RV64IZFINXZDINX-NEXT:    snez a0, a0
1645 ; RV64IZFINXZDINX-NEXT:    ret
1646 ;
1647 ; RV32I-LABEL: isnan_d_fpclass:
1648 ; RV32I:       # %bb.0:
1649 ; RV32I-NEXT:    slli a1, a1, 1
1650 ; RV32I-NEXT:    srli a1, a1, 1
1651 ; RV32I-NEXT:    lui a2, 524032
1652 ; RV32I-NEXT:    beq a1, a2, .LBB29_2
1653 ; RV32I-NEXT:  # %bb.1:
1654 ; RV32I-NEXT:    slt a0, a2, a1
1655 ; RV32I-NEXT:    ret
1656 ; RV32I-NEXT:  .LBB29_2:
1657 ; RV32I-NEXT:    snez a0, a0
1658 ; RV32I-NEXT:    ret
1659 ;
1660 ; RV64I-LABEL: isnan_d_fpclass:
1661 ; RV64I:       # %bb.0:
1662 ; RV64I-NEXT:    slli a0, a0, 1
1663 ; RV64I-NEXT:    srli a0, a0, 1
1664 ; RV64I-NEXT:    li a1, 2047
1665 ; RV64I-NEXT:    slli a1, a1, 52
1666 ; RV64I-NEXT:    slt a0, a1, a0
1667 ; RV64I-NEXT:    ret
1668   %1 = call i1 @llvm.is.fpclass.f64(double %x, i32 3)  ; nan
1669   ret i1 %1
1670 }