llvm/test/CodeGen/RISCV/llvm.frexp.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 2
   2 ; RUN: llc -mtriple=riscv32 -mattr=+d \
   3 ; RUN:   -verify-machineinstrs -target-abi=ilp32d < %s \
   4 ; RUN:   | FileCheck -check-prefix=RV32IFD %s
   5 ; RUN: llc -mtriple=riscv64 -mattr=+d \
   6 ; RUN:   -verify-machineinstrs -target-abi=lp64d < %s \
   7 ; RUN:   | FileCheck -check-prefix=RV64IFD %s
   8 ; RUN: llc -mtriple=riscv32 -mattr=+zdinx \
   9 ; RUN:   -verify-machineinstrs -target-abi=ilp32 < %s \
  10 ; RUN:   | FileCheck -check-prefix=RV32IZFINXZDINX %s
  11 ; RUN: llc -mtriple=riscv64 -mattr=+zdinx \
  12 ; RUN:   -verify-machineinstrs -target-abi=lp64 < %s \
  13 ; RUN:   | FileCheck -check-prefix=RV64IZFINXZDINX %s
  14 ; RUN: llc -mtriple=riscv32 -verify-machineinstrs < %s \
  15 ; RUN:   | FileCheck -check-prefix=RV32I %s
  16 ; RUN: llc -mtriple=riscv64 -verify-machineinstrs < %s \
  17 ; RUN:   | FileCheck -check-prefix=RV64I %s
  18
  19 ; TODO: FIXMEs are copied blindly across from the X86 version of this test.
  20
  21 define { half, i32 } @test_frexp_f16_i32(half %a) nounwind {
  22 ; RV32IFD-LABEL: test_frexp_f16_i32:
  23 ; RV32IFD:       # %bb.0:
  24 ; RV32IFD-NEXT:    addi sp, sp, -16
  25 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
  26 ; RV32IFD-NEXT:    call __extendhfsf2
  27 ; RV32IFD-NEXT:    addi a0, sp, 8
  28 ; RV32IFD-NEXT:    call frexpf
  29 ; RV32IFD-NEXT:    call __truncsfhf2
  30 ; RV32IFD-NEXT:    fmv.x.w a1, fa0
  31 ; RV32IFD-NEXT:    lw a0, 8(sp)
  32 ; RV32IFD-NEXT:    lui a2, 1048560
  33 ; RV32IFD-NEXT:    or a1, a1, a2
  34 ; RV32IFD-NEXT:    fmv.w.x fa0, a1
  35 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
  36 ; RV32IFD-NEXT:    addi sp, sp, 16
  37 ; RV32IFD-NEXT:    ret
  38 ;
  39 ; RV64IFD-LABEL: test_frexp_f16_i32:
  40 ; RV64IFD:       # %bb.0:
  41 ; RV64IFD-NEXT:    addi sp, sp, -16
  42 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  43 ; RV64IFD-NEXT:    call __extendhfsf2
  44 ; RV64IFD-NEXT:    mv a0, sp
  45 ; RV64IFD-NEXT:    call frexpf
  46 ; RV64IFD-NEXT:    call __truncsfhf2
  47 ; RV64IFD-NEXT:    fmv.x.w a1, fa0
  48 ; RV64IFD-NEXT:    ld a0, 0(sp)
  49 ; RV64IFD-NEXT:    lui a2, 1048560
  50 ; RV64IFD-NEXT:    or a1, a1, a2
  51 ; RV64IFD-NEXT:    fmv.w.x fa0, a1
  52 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  53 ; RV64IFD-NEXT:    addi sp, sp, 16
  54 ; RV64IFD-NEXT:    ret
  55 ;
  56 ; RV32IZFINXZDINX-LABEL: test_frexp_f16_i32:
  57 ; RV32IZFINXZDINX:       # %bb.0:
  58 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
  59 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
  60 ; RV32IZFINXZDINX-NEXT:    call __extendhfsf2
  61 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 8
  62 ; RV32IZFINXZDINX-NEXT:    call frexpf
  63 ; RV32IZFINXZDINX-NEXT:    call __truncsfhf2
  64 ; RV32IZFINXZDINX-NEXT:    lw a1, 8(sp)
  65 ; RV32IZFINXZDINX-NEXT:    lui a2, 1048560
  66 ; RV32IZFINXZDINX-NEXT:    or a0, a0, a2
  67 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
  68 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
  69 ; RV32IZFINXZDINX-NEXT:    ret
  70 ;
  71 ; RV64IZFINXZDINX-LABEL: test_frexp_f16_i32:
  72 ; RV64IZFINXZDINX:       # %bb.0:
  73 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
  74 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
  75 ; RV64IZFINXZDINX-NEXT:    call __extendhfsf2
  76 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
  77 ; RV64IZFINXZDINX-NEXT:    call frexpf
  78 ; RV64IZFINXZDINX-NEXT:    call __truncsfhf2
  79 ; RV64IZFINXZDINX-NEXT:    ld a1, 0(sp)
  80 ; RV64IZFINXZDINX-NEXT:    lui a2, 1048560
  81 ; RV64IZFINXZDINX-NEXT:    or a0, a0, a2
  82 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
  83 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
  84 ; RV64IZFINXZDINX-NEXT:    ret
  85 ;
  86 ; RV32I-LABEL: test_frexp_f16_i32:
  87 ; RV32I:       # %bb.0:
  88 ; RV32I-NEXT:    addi sp, sp, -16
  89 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
  90 ; RV32I-NEXT:    slli a0, a0, 16
  91 ; RV32I-NEXT:    srli a0, a0, 16
  92 ; RV32I-NEXT:    call __extendhfsf2
  93 ; RV32I-NEXT:    addi a1, sp, 8
  94 ; RV32I-NEXT:    call frexpf
  95 ; RV32I-NEXT:    call __truncsfhf2
  96 ; RV32I-NEXT:    lw a1, 8(sp)
  97 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
  98 ; RV32I-NEXT:    addi sp, sp, 16
  99 ; RV32I-NEXT:    ret
 100 ;
 101 ; RV64I-LABEL: test_frexp_f16_i32:
 102 ; RV64I:       # %bb.0:
 103 ; RV64I-NEXT:    addi sp, sp, -16
 104 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 105 ; RV64I-NEXT:    slli a0, a0, 48
 106 ; RV64I-NEXT:    srli a0, a0, 48
 107 ; RV64I-NEXT:    call __extendhfsf2
 108 ; RV64I-NEXT:    addi a1, sp, 4
 109 ; RV64I-NEXT:    call frexpf
 110 ; RV64I-NEXT:    call __truncsfhf2
 111 ; RV64I-NEXT:    lw a1, 4(sp)
 112 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 113 ; RV64I-NEXT:    addi sp, sp, 16
 114 ; RV64I-NEXT:    ret
 115   %result = call { half, i32 } @llvm.frexp.f16.i32(half %a)
 116   ret { half, i32 } %result
 117 }
 118
 119 define half @test_frexp_f16_i32_only_use_fract(half %a) nounwind {
 120 ; RV32IFD-LABEL: test_frexp_f16_i32_only_use_fract:
 121 ; RV32IFD:       # %bb.0:
 122 ; RV32IFD-NEXT:    addi sp, sp, -16
 123 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 124 ; RV32IFD-NEXT:    call __extendhfsf2
 125 ; RV32IFD-NEXT:    addi a0, sp, 8
 126 ; RV32IFD-NEXT:    call frexpf
 127 ; RV32IFD-NEXT:    call __truncsfhf2
 128 ; RV32IFD-NEXT:    fmv.x.w a0, fa0
 129 ; RV32IFD-NEXT:    lui a1, 1048560
 130 ; RV32IFD-NEXT:    or a0, a0, a1
 131 ; RV32IFD-NEXT:    fmv.w.x fa0, a0
 132 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 133 ; RV32IFD-NEXT:    addi sp, sp, 16
 134 ; RV32IFD-NEXT:    ret
 135 ;
 136 ; RV64IFD-LABEL: test_frexp_f16_i32_only_use_fract:
 137 ; RV64IFD:       # %bb.0:
 138 ; RV64IFD-NEXT:    addi sp, sp, -16
 139 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 140 ; RV64IFD-NEXT:    call __extendhfsf2
 141 ; RV64IFD-NEXT:    mv a0, sp
 142 ; RV64IFD-NEXT:    call frexpf
 143 ; RV64IFD-NEXT:    call __truncsfhf2
 144 ; RV64IFD-NEXT:    fmv.x.w a0, fa0
 145 ; RV64IFD-NEXT:    lui a1, 1048560
 146 ; RV64IFD-NEXT:    or a0, a0, a1
 147 ; RV64IFD-NEXT:    fmv.w.x fa0, a0
 148 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 149 ; RV64IFD-NEXT:    addi sp, sp, 16
 150 ; RV64IFD-NEXT:    ret
 151 ;
 152 ; RV32IZFINXZDINX-LABEL: test_frexp_f16_i32_only_use_fract:
 153 ; RV32IZFINXZDINX:       # %bb.0:
 154 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 155 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 156 ; RV32IZFINXZDINX-NEXT:    call __extendhfsf2
 157 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 8
 158 ; RV32IZFINXZDINX-NEXT:    call frexpf
 159 ; RV32IZFINXZDINX-NEXT:    call __truncsfhf2
 160 ; RV32IZFINXZDINX-NEXT:    lui a1, 1048560
 161 ; RV32IZFINXZDINX-NEXT:    or a0, a0, a1
 162 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 163 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 164 ; RV32IZFINXZDINX-NEXT:    ret
 165 ;
 166 ; RV64IZFINXZDINX-LABEL: test_frexp_f16_i32_only_use_fract:
 167 ; RV64IZFINXZDINX:       # %bb.0:
 168 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
 169 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 170 ; RV64IZFINXZDINX-NEXT:    call __extendhfsf2
 171 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
 172 ; RV64IZFINXZDINX-NEXT:    call frexpf
 173 ; RV64IZFINXZDINX-NEXT:    call __truncsfhf2
 174 ; RV64IZFINXZDINX-NEXT:    lui a1, 1048560
 175 ; RV64IZFINXZDINX-NEXT:    or a0, a0, a1
 176 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 177 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
 178 ; RV64IZFINXZDINX-NEXT:    ret
 179 ;
 180 ; RV32I-LABEL: test_frexp_f16_i32_only_use_fract:
 181 ; RV32I:       # %bb.0:
 182 ; RV32I-NEXT:    addi sp, sp, -16
 183 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 184 ; RV32I-NEXT:    slli a0, a0, 16
 185 ; RV32I-NEXT:    srli a0, a0, 16
 186 ; RV32I-NEXT:    call __extendhfsf2
 187 ; RV32I-NEXT:    addi a1, sp, 8
 188 ; RV32I-NEXT:    call frexpf
 189 ; RV32I-NEXT:    call __truncsfhf2
 190 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 191 ; RV32I-NEXT:    addi sp, sp, 16
 192 ; RV32I-NEXT:    ret
 193 ;
 194 ; RV64I-LABEL: test_frexp_f16_i32_only_use_fract:
 195 ; RV64I:       # %bb.0:
 196 ; RV64I-NEXT:    addi sp, sp, -16
 197 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 198 ; RV64I-NEXT:    slli a0, a0, 48
 199 ; RV64I-NEXT:    srli a0, a0, 48
 200 ; RV64I-NEXT:    call __extendhfsf2
 201 ; RV64I-NEXT:    addi a1, sp, 4
 202 ; RV64I-NEXT:    call frexpf
 203 ; RV64I-NEXT:    call __truncsfhf2
 204 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 205 ; RV64I-NEXT:    addi sp, sp, 16
 206 ; RV64I-NEXT:    ret
 207   %result = call { half, i32 } @llvm.frexp.f16.i32(half %a)
 208   %result.0 = extractvalue { half, i32 } %result, 0
 209   ret half %result.0
 210 }
 211
 212 define i32 @test_frexp_f16_i32_only_use_exp(half %a) nounwind {
 213 ; RV32IFD-LABEL: test_frexp_f16_i32_only_use_exp:
 214 ; RV32IFD:       # %bb.0:
 215 ; RV32IFD-NEXT:    addi sp, sp, -16
 216 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 217 ; RV32IFD-NEXT:    call __extendhfsf2
 218 ; RV32IFD-NEXT:    addi a0, sp, 8
 219 ; RV32IFD-NEXT:    call frexpf
 220 ; RV32IFD-NEXT:    lw a0, 8(sp)
 221 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 222 ; RV32IFD-NEXT:    addi sp, sp, 16
 223 ; RV32IFD-NEXT:    ret
 224 ;
 225 ; RV64IFD-LABEL: test_frexp_f16_i32_only_use_exp:
 226 ; RV64IFD:       # %bb.0:
 227 ; RV64IFD-NEXT:    addi sp, sp, -16
 228 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 229 ; RV64IFD-NEXT:    call __extendhfsf2
 230 ; RV64IFD-NEXT:    mv a0, sp
 231 ; RV64IFD-NEXT:    call frexpf
 232 ; RV64IFD-NEXT:    ld a0, 0(sp)
 233 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 234 ; RV64IFD-NEXT:    addi sp, sp, 16
 235 ; RV64IFD-NEXT:    ret
 236 ;
 237 ; RV32IZFINXZDINX-LABEL: test_frexp_f16_i32_only_use_exp:
 238 ; RV32IZFINXZDINX:       # %bb.0:
 239 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 240 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 241 ; RV32IZFINXZDINX-NEXT:    call __extendhfsf2
 242 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 8
 243 ; RV32IZFINXZDINX-NEXT:    call frexpf
 244 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 245 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 246 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 247 ; RV32IZFINXZDINX-NEXT:    ret
 248 ;
 249 ; RV64IZFINXZDINX-LABEL: test_frexp_f16_i32_only_use_exp:
 250 ; RV64IZFINXZDINX:       # %bb.0:
 251 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
 252 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 253 ; RV64IZFINXZDINX-NEXT:    call __extendhfsf2
 254 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
 255 ; RV64IZFINXZDINX-NEXT:    call frexpf
 256 ; RV64IZFINXZDINX-NEXT:    ld a0, 0(sp)
 257 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 258 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
 259 ; RV64IZFINXZDINX-NEXT:    ret
 260 ;
 261 ; RV32I-LABEL: test_frexp_f16_i32_only_use_exp:
 262 ; RV32I:       # %bb.0:
 263 ; RV32I-NEXT:    addi sp, sp, -16
 264 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 265 ; RV32I-NEXT:    slli a0, a0, 16
 266 ; RV32I-NEXT:    srli a0, a0, 16
 267 ; RV32I-NEXT:    call __extendhfsf2
 268 ; RV32I-NEXT:    addi a1, sp, 8
 269 ; RV32I-NEXT:    call frexpf
 270 ; RV32I-NEXT:    lw a0, 8(sp)
 271 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 272 ; RV32I-NEXT:    addi sp, sp, 16
 273 ; RV32I-NEXT:    ret
 274 ;
 275 ; RV64I-LABEL: test_frexp_f16_i32_only_use_exp:
 276 ; RV64I:       # %bb.0:
 277 ; RV64I-NEXT:    addi sp, sp, -16
 278 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 279 ; RV64I-NEXT:    slli a0, a0, 48
 280 ; RV64I-NEXT:    srli a0, a0, 48
 281 ; RV64I-NEXT:    call __extendhfsf2
 282 ; RV64I-NEXT:    addi a1, sp, 4
 283 ; RV64I-NEXT:    call frexpf
 284 ; RV64I-NEXT:    lw a0, 4(sp)
 285 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 286 ; RV64I-NEXT:    addi sp, sp, 16
 287 ; RV64I-NEXT:    ret
 288   %result = call { half, i32 } @llvm.frexp.f16.i32(half %a)
 289   %result.0 = extractvalue { half, i32 } %result, 1
 290   ret i32 %result.0
 291 }
 292
 293 ; FIXME
 294 ; define { <2 x half>, <2 x i32> } @test_frexp_v2f16_v2i32(<2 x half> %a) nounwind {
 295 ;   %result = call { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half> %a)
 296 ;   ret { <2 x half>, <2 x i32> } %result
 297 ; }
 298
 299 ; define <2 x half> @test_frexp_v2f16_v2i32_only_use_fract(<2 x half> %a) nounwind {
 300 ;   %result = call { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half> %a)
 301 ;   %result.0 = extractvalue { <2 x half>, <2 x i32> } %result, 0
 302 ;   ret <2 x half> %result.0
 303 ; }
 304
 305 ; define <2 x i32> @test_frexp_v2f16_v2i32_only_use_exp(<2 x half> %a) nounwind {
 306 ;   %result = call { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half> %a)
 307 ;   %result.1 = extractvalue { <2 x half>, <2 x i32> } %result, 1
 308 ;   ret <2 x i32> %result.1
 309 ; }
 310
 311 define { float, i32 } @test_frexp_f32_i32(float %a) nounwind {
 312 ; RV32IFD-LABEL: test_frexp_f32_i32:
 313 ; RV32IFD:       # %bb.0:
 314 ; RV32IFD-NEXT:    addi sp, sp, -16
 315 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 316 ; RV32IFD-NEXT:    addi a0, sp, 8
 317 ; RV32IFD-NEXT:    call frexpf
 318 ; RV32IFD-NEXT:    lw a0, 8(sp)
 319 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 320 ; RV32IFD-NEXT:    addi sp, sp, 16
 321 ; RV32IFD-NEXT:    ret
 322 ;
 323 ; RV64IFD-LABEL: test_frexp_f32_i32:
 324 ; RV64IFD:       # %bb.0:
 325 ; RV64IFD-NEXT:    addi sp, sp, -16
 326 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 327 ; RV64IFD-NEXT:    mv a0, sp
 328 ; RV64IFD-NEXT:    call frexpf
 329 ; RV64IFD-NEXT:    ld a0, 0(sp)
 330 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 331 ; RV64IFD-NEXT:    addi sp, sp, 16
 332 ; RV64IFD-NEXT:    ret
 333 ;
 334 ; RV32IZFINXZDINX-LABEL: test_frexp_f32_i32:
 335 ; RV32IZFINXZDINX:       # %bb.0:
 336 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 337 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 338 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 8
 339 ; RV32IZFINXZDINX-NEXT:    call frexpf
 340 ; RV32IZFINXZDINX-NEXT:    lw a1, 8(sp)
 341 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 342 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 343 ; RV32IZFINXZDINX-NEXT:    ret
 344 ;
 345 ; RV64IZFINXZDINX-LABEL: test_frexp_f32_i32:
 346 ; RV64IZFINXZDINX:       # %bb.0:
 347 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
 348 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 349 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
 350 ; RV64IZFINXZDINX-NEXT:    call frexpf
 351 ; RV64IZFINXZDINX-NEXT:    ld a1, 0(sp)
 352 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 353 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
 354 ; RV64IZFINXZDINX-NEXT:    ret
 355 ;
 356 ; RV32I-LABEL: test_frexp_f32_i32:
 357 ; RV32I:       # %bb.0:
 358 ; RV32I-NEXT:    addi sp, sp, -16
 359 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 360 ; RV32I-NEXT:    addi a1, sp, 8
 361 ; RV32I-NEXT:    call frexpf
 362 ; RV32I-NEXT:    lw a1, 8(sp)
 363 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 364 ; RV32I-NEXT:    addi sp, sp, 16
 365 ; RV32I-NEXT:    ret
 366 ;
 367 ; RV64I-LABEL: test_frexp_f32_i32:
 368 ; RV64I:       # %bb.0:
 369 ; RV64I-NEXT:    addi sp, sp, -16
 370 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 371 ; RV64I-NEXT:    addi a1, sp, 4
 372 ; RV64I-NEXT:    call frexpf
 373 ; RV64I-NEXT:    lw a1, 4(sp)
 374 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 375 ; RV64I-NEXT:    addi sp, sp, 16
 376 ; RV64I-NEXT:    ret
 377   %result = call { float, i32 } @llvm.frexp.f32.i32(float %a)
 378   ret { float, i32 } %result
 379 }
 380
 381 define float @test_frexp_f32_i32_only_use_fract(float %a) nounwind {
 382 ; RV32IFD-LABEL: test_frexp_f32_i32_only_use_fract:
 383 ; RV32IFD:       # %bb.0:
 384 ; RV32IFD-NEXT:    addi sp, sp, -16
 385 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 386 ; RV32IFD-NEXT:    addi a0, sp, 8
 387 ; RV32IFD-NEXT:    call frexpf
 388 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 389 ; RV32IFD-NEXT:    addi sp, sp, 16
 390 ; RV32IFD-NEXT:    ret
 391 ;
 392 ; RV64IFD-LABEL: test_frexp_f32_i32_only_use_fract:
 393 ; RV64IFD:       # %bb.0:
 394 ; RV64IFD-NEXT:    addi sp, sp, -16
 395 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 396 ; RV64IFD-NEXT:    mv a0, sp
 397 ; RV64IFD-NEXT:    call frexpf
 398 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 399 ; RV64IFD-NEXT:    addi sp, sp, 16
 400 ; RV64IFD-NEXT:    ret
 401 ;
 402 ; RV32IZFINXZDINX-LABEL: test_frexp_f32_i32_only_use_fract:
 403 ; RV32IZFINXZDINX:       # %bb.0:
 404 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 405 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 406 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 8
 407 ; RV32IZFINXZDINX-NEXT:    call frexpf
 408 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 409 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 410 ; RV32IZFINXZDINX-NEXT:    ret
 411 ;
 412 ; RV64IZFINXZDINX-LABEL: test_frexp_f32_i32_only_use_fract:
 413 ; RV64IZFINXZDINX:       # %bb.0:
 414 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
 415 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 416 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
 417 ; RV64IZFINXZDINX-NEXT:    call frexpf
 418 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 419 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
 420 ; RV64IZFINXZDINX-NEXT:    ret
 421 ;
 422 ; RV32I-LABEL: test_frexp_f32_i32_only_use_fract:
 423 ; RV32I:       # %bb.0:
 424 ; RV32I-NEXT:    addi sp, sp, -16
 425 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 426 ; RV32I-NEXT:    addi a1, sp, 8
 427 ; RV32I-NEXT:    call frexpf
 428 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 429 ; RV32I-NEXT:    addi sp, sp, 16
 430 ; RV32I-NEXT:    ret
 431 ;
 432 ; RV64I-LABEL: test_frexp_f32_i32_only_use_fract:
 433 ; RV64I:       # %bb.0:
 434 ; RV64I-NEXT:    addi sp, sp, -16
 435 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 436 ; RV64I-NEXT:    addi a1, sp, 4
 437 ; RV64I-NEXT:    call frexpf
 438 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 439 ; RV64I-NEXT:    addi sp, sp, 16
 440 ; RV64I-NEXT:    ret
 441   %result = call { float, i32 } @llvm.frexp.f32.i32(float %a)
 442   %result.0 = extractvalue { float, i32 } %result, 0
 443   ret float %result.0
 444 }
 445
 446 define i32 @test_frexp_f32_i32_only_use_exp(float %a) nounwind {
 447 ; RV32IFD-LABEL: test_frexp_f32_i32_only_use_exp:
 448 ; RV32IFD:       # %bb.0:
 449 ; RV32IFD-NEXT:    addi sp, sp, -16
 450 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 451 ; RV32IFD-NEXT:    addi a0, sp, 8
 452 ; RV32IFD-NEXT:    call frexpf
 453 ; RV32IFD-NEXT:    lw a0, 8(sp)
 454 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 455 ; RV32IFD-NEXT:    addi sp, sp, 16
 456 ; RV32IFD-NEXT:    ret
 457 ;
 458 ; RV64IFD-LABEL: test_frexp_f32_i32_only_use_exp:
 459 ; RV64IFD:       # %bb.0:
 460 ; RV64IFD-NEXT:    addi sp, sp, -16
 461 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 462 ; RV64IFD-NEXT:    mv a0, sp
 463 ; RV64IFD-NEXT:    call frexpf
 464 ; RV64IFD-NEXT:    ld a0, 0(sp)
 465 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 466 ; RV64IFD-NEXT:    addi sp, sp, 16
 467 ; RV64IFD-NEXT:    ret
 468 ;
 469 ; RV32IZFINXZDINX-LABEL: test_frexp_f32_i32_only_use_exp:
 470 ; RV32IZFINXZDINX:       # %bb.0:
 471 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
 472 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 473 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 8
 474 ; RV32IZFINXZDINX-NEXT:    call frexpf
 475 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
 476 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 477 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
 478 ; RV32IZFINXZDINX-NEXT:    ret
 479 ;
 480 ; RV64IZFINXZDINX-LABEL: test_frexp_f32_i32_only_use_exp:
 481 ; RV64IZFINXZDINX:       # %bb.0:
 482 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
 483 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 484 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
 485 ; RV64IZFINXZDINX-NEXT:    call frexpf
 486 ; RV64IZFINXZDINX-NEXT:    ld a0, 0(sp)
 487 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 488 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
 489 ; RV64IZFINXZDINX-NEXT:    ret
 490 ;
 491 ; RV32I-LABEL: test_frexp_f32_i32_only_use_exp:
 492 ; RV32I:       # %bb.0:
 493 ; RV32I-NEXT:    addi sp, sp, -16
 494 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
 495 ; RV32I-NEXT:    addi a1, sp, 8
 496 ; RV32I-NEXT:    call frexpf
 497 ; RV32I-NEXT:    lw a0, 8(sp)
 498 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
 499 ; RV32I-NEXT:    addi sp, sp, 16
 500 ; RV32I-NEXT:    ret
 501 ;
 502 ; RV64I-LABEL: test_frexp_f32_i32_only_use_exp:
 503 ; RV64I:       # %bb.0:
 504 ; RV64I-NEXT:    addi sp, sp, -16
 505 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
 506 ; RV64I-NEXT:    addi a1, sp, 4
 507 ; RV64I-NEXT:    call frexpf
 508 ; RV64I-NEXT:    lw a0, 4(sp)
 509 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
 510 ; RV64I-NEXT:    addi sp, sp, 16
 511 ; RV64I-NEXT:    ret
 512   %result = call { float, i32 } @llvm.frexp.f32.i32(float %a)
 513   %result.0 = extractvalue { float, i32 } %result, 1
 514   ret i32 %result.0
 515 }
 516
 517 ; FIXME: Widen vector result
 518 ; define { <2 x float>, <2 x i32> } @test_frexp_v2f32_v2i32(<2 x float> %a) nounwind {
 519 ;   %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a)
 520 ;   ret { <2 x float>, <2 x i32> } %result
 521 ; }
 522
 523 ; define <2 x float> @test_frexp_v2f32_v2i32_only_use_fract(<2 x float> %a) nounwind {
 524 ;   %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a)
 525 ;   %result.0 = extractvalue { <2 x float>, <2 x i32> } %result, 0
 526 ;   ret <2 x float> %result.0
 527 ; }
 528
 529 ; define <2 x i32> @test_frexp_v2f32_v2i32_only_use_exp(<2 x float> %a) nounwind {
 530 ;   %result = call { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float> %a)
 531 ;   %result.1 = extractvalue { <2 x float>, <2 x i32> } %result, 1
 532 ;   ret <2 x i32> %result.1
 533 ; }
 534
 535 define { <4 x float>, <4 x i32> } @test_frexp_v4f32_v4i32(<4 x float> %a) nounwind {
 536 ; RV32IFD-LABEL: test_frexp_v4f32_v4i32:
 537 ; RV32IFD:       # %bb.0:
 538 ; RV32IFD-NEXT:    addi sp, sp, -64
 539 ; RV32IFD-NEXT:    sw ra, 60(sp) # 4-byte Folded Spill
 540 ; RV32IFD-NEXT:    sw s0, 56(sp) # 4-byte Folded Spill
 541 ; RV32IFD-NEXT:    fsd fs0, 48(sp) # 8-byte Folded Spill
 542 ; RV32IFD-NEXT:    fsd fs1, 40(sp) # 8-byte Folded Spill
 543 ; RV32IFD-NEXT:    fsd fs2, 32(sp) # 8-byte Folded Spill
 544 ; RV32IFD-NEXT:    fsd fs3, 24(sp) # 8-byte Folded Spill
 545 ; RV32IFD-NEXT:    fmv.s fs0, fa3
 546 ; RV32IFD-NEXT:    fmv.s fs1, fa2
 547 ; RV32IFD-NEXT:    fmv.s fs2, fa1
 548 ; RV32IFD-NEXT:    mv s0, a0
 549 ; RV32IFD-NEXT:    addi a0, sp, 8
 550 ; RV32IFD-NEXT:    call frexpf
 551 ; RV32IFD-NEXT:    fmv.s fs3, fa0
 552 ; RV32IFD-NEXT:    addi a0, sp, 12
 553 ; RV32IFD-NEXT:    fmv.s fa0, fs2
 554 ; RV32IFD-NEXT:    call frexpf
 555 ; RV32IFD-NEXT:    fmv.s fs2, fa0
 556 ; RV32IFD-NEXT:    addi a0, sp, 16
 557 ; RV32IFD-NEXT:    fmv.s fa0, fs1
 558 ; RV32IFD-NEXT:    call frexpf
 559 ; RV32IFD-NEXT:    fmv.s fs1, fa0
 560 ; RV32IFD-NEXT:    addi a0, sp, 20
 561 ; RV32IFD-NEXT:    fmv.s fa0, fs0
 562 ; RV32IFD-NEXT:    call frexpf
 563 ; RV32IFD-NEXT:    lw a0, 20(sp)
 564 ; RV32IFD-NEXT:    lw a1, 16(sp)
 565 ; RV32IFD-NEXT:    lw a2, 12(sp)
 566 ; RV32IFD-NEXT:    lw a3, 8(sp)
 567 ; RV32IFD-NEXT:    sw a0, 28(s0)
 568 ; RV32IFD-NEXT:    sw a1, 24(s0)
 569 ; RV32IFD-NEXT:    sw a2, 20(s0)
 570 ; RV32IFD-NEXT:    sw a3, 16(s0)
 571 ; RV32IFD-NEXT:    fsw fa0, 12(s0)
 572 ; RV32IFD-NEXT:    fsw fs1, 8(s0)
 573 ; RV32IFD-NEXT:    fsw fs2, 4(s0)
 574 ; RV32IFD-NEXT:    fsw fs3, 0(s0)
 575 ; RV32IFD-NEXT:    lw ra, 60(sp) # 4-byte Folded Reload
 576 ; RV32IFD-NEXT:    lw s0, 56(sp) # 4-byte Folded Reload
 577 ; RV32IFD-NEXT:    fld fs0, 48(sp) # 8-byte Folded Reload
 578 ; RV32IFD-NEXT:    fld fs1, 40(sp) # 8-byte Folded Reload
 579 ; RV32IFD-NEXT:    fld fs2, 32(sp) # 8-byte Folded Reload
 580 ; RV32IFD-NEXT:    fld fs3, 24(sp) # 8-byte Folded Reload
 581 ; RV32IFD-NEXT:    addi sp, sp, 64
 582 ; RV32IFD-NEXT:    ret
 583 ;
 584 ; RV64IFD-LABEL: test_frexp_v4f32_v4i32:
 585 ; RV64IFD:       # %bb.0:
 586 ; RV64IFD-NEXT:    addi sp, sp, -80
 587 ; RV64IFD-NEXT:    sd ra, 72(sp) # 8-byte Folded Spill
 588 ; RV64IFD-NEXT:    sd s0, 64(sp) # 8-byte Folded Spill
 589 ; RV64IFD-NEXT:    fsd fs0, 56(sp) # 8-byte Folded Spill
 590 ; RV64IFD-NEXT:    fsd fs1, 48(sp) # 8-byte Folded Spill
 591 ; RV64IFD-NEXT:    fsd fs2, 40(sp) # 8-byte Folded Spill
 592 ; RV64IFD-NEXT:    fsd fs3, 32(sp) # 8-byte Folded Spill
 593 ; RV64IFD-NEXT:    fmv.s fs0, fa3
 594 ; RV64IFD-NEXT:    fmv.s fs1, fa2
 595 ; RV64IFD-NEXT:    fmv.s fs2, fa1
 596 ; RV64IFD-NEXT:    mv s0, a0
 597 ; RV64IFD-NEXT:    mv a0, sp
 598 ; RV64IFD-NEXT:    call frexpf
 599 ; RV64IFD-NEXT:    fmv.s fs3, fa0
 600 ; RV64IFD-NEXT:    addi a0, sp, 8
 601 ; RV64IFD-NEXT:    fmv.s fa0, fs2
 602 ; RV64IFD-NEXT:    call frexpf
 603 ; RV64IFD-NEXT:    fmv.s fs2, fa0
 604 ; RV64IFD-NEXT:    addi a0, sp, 16
 605 ; RV64IFD-NEXT:    fmv.s fa0, fs1
 606 ; RV64IFD-NEXT:    call frexpf
 607 ; RV64IFD-NEXT:    fmv.s fs1, fa0
 608 ; RV64IFD-NEXT:    addi a0, sp, 24
 609 ; RV64IFD-NEXT:    fmv.s fa0, fs0
 610 ; RV64IFD-NEXT:    call frexpf
 611 ; RV64IFD-NEXT:    ld a0, 24(sp)
 612 ; RV64IFD-NEXT:    ld a1, 16(sp)
 613 ; RV64IFD-NEXT:    ld a2, 8(sp)
 614 ; RV64IFD-NEXT:    ld a3, 0(sp)
 615 ; RV64IFD-NEXT:    sw a0, 28(s0)
 616 ; RV64IFD-NEXT:    sw a1, 24(s0)
 617 ; RV64IFD-NEXT:    sw a2, 20(s0)
 618 ; RV64IFD-NEXT:    sw a3, 16(s0)
 619 ; RV64IFD-NEXT:    fsw fa0, 12(s0)
 620 ; RV64IFD-NEXT:    fsw fs1, 8(s0)
 621 ; RV64IFD-NEXT:    fsw fs2, 4(s0)
 622 ; RV64IFD-NEXT:    fsw fs3, 0(s0)
 623 ; RV64IFD-NEXT:    ld ra, 72(sp) # 8-byte Folded Reload
 624 ; RV64IFD-NEXT:    ld s0, 64(sp) # 8-byte Folded Reload
 625 ; RV64IFD-NEXT:    fld fs0, 56(sp) # 8-byte Folded Reload
 626 ; RV64IFD-NEXT:    fld fs1, 48(sp) # 8-byte Folded Reload
 627 ; RV64IFD-NEXT:    fld fs2, 40(sp) # 8-byte Folded Reload
 628 ; RV64IFD-NEXT:    fld fs3, 32(sp) # 8-byte Folded Reload
 629 ; RV64IFD-NEXT:    addi sp, sp, 80
 630 ; RV64IFD-NEXT:    ret
 631 ;
 632 ; RV32IZFINXZDINX-LABEL: test_frexp_v4f32_v4i32:
 633 ; RV32IZFINXZDINX:       # %bb.0:
 634 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -48
 635 ; RV32IZFINXZDINX-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
 636 ; RV32IZFINXZDINX-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
 637 ; RV32IZFINXZDINX-NEXT:    sw s1, 36(sp) # 4-byte Folded Spill
 638 ; RV32IZFINXZDINX-NEXT:    sw s2, 32(sp) # 4-byte Folded Spill
 639 ; RV32IZFINXZDINX-NEXT:    sw s3, 28(sp) # 4-byte Folded Spill
 640 ; RV32IZFINXZDINX-NEXT:    sw s4, 24(sp) # 4-byte Folded Spill
 641 ; RV32IZFINXZDINX-NEXT:    mv s0, a4
 642 ; RV32IZFINXZDINX-NEXT:    mv s1, a3
 643 ; RV32IZFINXZDINX-NEXT:    mv s2, a2
 644 ; RV32IZFINXZDINX-NEXT:    mv a2, a1
 645 ; RV32IZFINXZDINX-NEXT:    mv s3, a0
 646 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 8
 647 ; RV32IZFINXZDINX-NEXT:    mv a0, a2
 648 ; RV32IZFINXZDINX-NEXT:    call frexpf
 649 ; RV32IZFINXZDINX-NEXT:    mv s4, a0
 650 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 12
 651 ; RV32IZFINXZDINX-NEXT:    mv a0, s2
 652 ; RV32IZFINXZDINX-NEXT:    call frexpf
 653 ; RV32IZFINXZDINX-NEXT:    mv s2, a0
 654 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 16
 655 ; RV32IZFINXZDINX-NEXT:    mv a0, s1
 656 ; RV32IZFINXZDINX-NEXT:    call frexpf
 657 ; RV32IZFINXZDINX-NEXT:    mv s1, a0
 658 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 20
 659 ; RV32IZFINXZDINX-NEXT:    mv a0, s0
 660 ; RV32IZFINXZDINX-NEXT:    call frexpf
 661 ; RV32IZFINXZDINX-NEXT:    lw a1, 20(sp)
 662 ; RV32IZFINXZDINX-NEXT:    lw a2, 16(sp)
 663 ; RV32IZFINXZDINX-NEXT:    lw a3, 12(sp)
 664 ; RV32IZFINXZDINX-NEXT:    lw a4, 8(sp)
 665 ; RV32IZFINXZDINX-NEXT:    sw a1, 28(s3)
 666 ; RV32IZFINXZDINX-NEXT:    sw a2, 24(s3)
 667 ; RV32IZFINXZDINX-NEXT:    sw a3, 20(s3)
 668 ; RV32IZFINXZDINX-NEXT:    sw a4, 16(s3)
 669 ; RV32IZFINXZDINX-NEXT:    sw a0, 12(s3)
 670 ; RV32IZFINXZDINX-NEXT:    sw s1, 8(s3)
 671 ; RV32IZFINXZDINX-NEXT:    sw s2, 4(s3)
 672 ; RV32IZFINXZDINX-NEXT:    sw s4, 0(s3)
 673 ; RV32IZFINXZDINX-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
 674 ; RV32IZFINXZDINX-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
 675 ; RV32IZFINXZDINX-NEXT:    lw s1, 36(sp) # 4-byte Folded Reload
 676 ; RV32IZFINXZDINX-NEXT:    lw s2, 32(sp) # 4-byte Folded Reload
 677 ; RV32IZFINXZDINX-NEXT:    lw s3, 28(sp) # 4-byte Folded Reload
 678 ; RV32IZFINXZDINX-NEXT:    lw s4, 24(sp) # 4-byte Folded Reload
 679 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 48
 680 ; RV32IZFINXZDINX-NEXT:    ret
 681 ;
 682 ; RV64IZFINXZDINX-LABEL: test_frexp_v4f32_v4i32:
 683 ; RV64IZFINXZDINX:       # %bb.0:
 684 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -80
 685 ; RV64IZFINXZDINX-NEXT:    sd ra, 72(sp) # 8-byte Folded Spill
 686 ; RV64IZFINXZDINX-NEXT:    sd s0, 64(sp) # 8-byte Folded Spill
 687 ; RV64IZFINXZDINX-NEXT:    sd s1, 56(sp) # 8-byte Folded Spill
 688 ; RV64IZFINXZDINX-NEXT:    sd s2, 48(sp) # 8-byte Folded Spill
 689 ; RV64IZFINXZDINX-NEXT:    sd s3, 40(sp) # 8-byte Folded Spill
 690 ; RV64IZFINXZDINX-NEXT:    sd s4, 32(sp) # 8-byte Folded Spill
 691 ; RV64IZFINXZDINX-NEXT:    mv s0, a4
 692 ; RV64IZFINXZDINX-NEXT:    mv s1, a3
 693 ; RV64IZFINXZDINX-NEXT:    mv s2, a2
 694 ; RV64IZFINXZDINX-NEXT:    mv a2, a1
 695 ; RV64IZFINXZDINX-NEXT:    mv s3, a0
 696 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
 697 ; RV64IZFINXZDINX-NEXT:    mv a0, a2
 698 ; RV64IZFINXZDINX-NEXT:    call frexpf
 699 ; RV64IZFINXZDINX-NEXT:    mv s4, a0
 700 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 8
 701 ; RV64IZFINXZDINX-NEXT:    mv a0, s2
 702 ; RV64IZFINXZDINX-NEXT:    call frexpf
 703 ; RV64IZFINXZDINX-NEXT:    mv s2, a0
 704 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 16
 705 ; RV64IZFINXZDINX-NEXT:    mv a0, s1
 706 ; RV64IZFINXZDINX-NEXT:    call frexpf
 707 ; RV64IZFINXZDINX-NEXT:    mv s1, a0
 708 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 24
 709 ; RV64IZFINXZDINX-NEXT:    mv a0, s0
 710 ; RV64IZFINXZDINX-NEXT:    call frexpf
 711 ; RV64IZFINXZDINX-NEXT:    ld a1, 24(sp)
 712 ; RV64IZFINXZDINX-NEXT:    ld a2, 16(sp)
 713 ; RV64IZFINXZDINX-NEXT:    ld a3, 8(sp)
 714 ; RV64IZFINXZDINX-NEXT:    ld a4, 0(sp)
 715 ; RV64IZFINXZDINX-NEXT:    sw a1, 28(s3)
 716 ; RV64IZFINXZDINX-NEXT:    sw a2, 24(s3)
 717 ; RV64IZFINXZDINX-NEXT:    sw a3, 20(s3)
 718 ; RV64IZFINXZDINX-NEXT:    sw a4, 16(s3)
 719 ; RV64IZFINXZDINX-NEXT:    sw a0, 12(s3)
 720 ; RV64IZFINXZDINX-NEXT:    sw s1, 8(s3)
 721 ; RV64IZFINXZDINX-NEXT:    sw s2, 4(s3)
 722 ; RV64IZFINXZDINX-NEXT:    sw s4, 0(s3)
 723 ; RV64IZFINXZDINX-NEXT:    ld ra, 72(sp) # 8-byte Folded Reload
 724 ; RV64IZFINXZDINX-NEXT:    ld s0, 64(sp) # 8-byte Folded Reload
 725 ; RV64IZFINXZDINX-NEXT:    ld s1, 56(sp) # 8-byte Folded Reload
 726 ; RV64IZFINXZDINX-NEXT:    ld s2, 48(sp) # 8-byte Folded Reload
 727 ; RV64IZFINXZDINX-NEXT:    ld s3, 40(sp) # 8-byte Folded Reload
 728 ; RV64IZFINXZDINX-NEXT:    ld s4, 32(sp) # 8-byte Folded Reload
 729 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 80
 730 ; RV64IZFINXZDINX-NEXT:    ret
 731 ;
 732 ; RV32I-LABEL: test_frexp_v4f32_v4i32:
 733 ; RV32I:       # %bb.0:
 734 ; RV32I-NEXT:    addi sp, sp, -48
 735 ; RV32I-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
 736 ; RV32I-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
 737 ; RV32I-NEXT:    sw s1, 36(sp) # 4-byte Folded Spill
 738 ; RV32I-NEXT:    sw s2, 32(sp) # 4-byte Folded Spill
 739 ; RV32I-NEXT:    sw s3, 28(sp) # 4-byte Folded Spill
 740 ; RV32I-NEXT:    sw s4, 24(sp) # 4-byte Folded Spill
 741 ; RV32I-NEXT:    lw s0, 12(a1)
 742 ; RV32I-NEXT:    lw s1, 8(a1)
 743 ; RV32I-NEXT:    lw s2, 4(a1)
 744 ; RV32I-NEXT:    lw a2, 0(a1)
 745 ; RV32I-NEXT:    mv s3, a0
 746 ; RV32I-NEXT:    addi a1, sp, 8
 747 ; RV32I-NEXT:    mv a0, a2
 748 ; RV32I-NEXT:    call frexpf
 749 ; RV32I-NEXT:    mv s4, a0
 750 ; RV32I-NEXT:    addi a1, sp, 12
 751 ; RV32I-NEXT:    mv a0, s2
 752 ; RV32I-NEXT:    call frexpf
 753 ; RV32I-NEXT:    mv s2, a0
 754 ; RV32I-NEXT:    addi a1, sp, 16
 755 ; RV32I-NEXT:    mv a0, s1
 756 ; RV32I-NEXT:    call frexpf
 757 ; RV32I-NEXT:    mv s1, a0
 758 ; RV32I-NEXT:    addi a1, sp, 20
 759 ; RV32I-NEXT:    mv a0, s0
 760 ; RV32I-NEXT:    call frexpf
 761 ; RV32I-NEXT:    lw a1, 8(sp)
 762 ; RV32I-NEXT:    lw a2, 12(sp)
 763 ; RV32I-NEXT:    lw a3, 16(sp)
 764 ; RV32I-NEXT:    lw a4, 20(sp)
 765 ; RV32I-NEXT:    sw a0, 12(s3)
 766 ; RV32I-NEXT:    sw s1, 8(s3)
 767 ; RV32I-NEXT:    sw s2, 4(s3)
 768 ; RV32I-NEXT:    sw s4, 0(s3)
 769 ; RV32I-NEXT:    sw a4, 28(s3)
 770 ; RV32I-NEXT:    sw a3, 24(s3)
 771 ; RV32I-NEXT:    sw a2, 20(s3)
 772 ; RV32I-NEXT:    sw a1, 16(s3)
 773 ; RV32I-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
 774 ; RV32I-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
 775 ; RV32I-NEXT:    lw s1, 36(sp) # 4-byte Folded Reload
 776 ; RV32I-NEXT:    lw s2, 32(sp) # 4-byte Folded Reload
 777 ; RV32I-NEXT:    lw s3, 28(sp) # 4-byte Folded Reload
 778 ; RV32I-NEXT:    lw s4, 24(sp) # 4-byte Folded Reload
 779 ; RV32I-NEXT:    addi sp, sp, 48
 780 ; RV32I-NEXT:    ret
 781 ;
 782 ; RV64I-LABEL: test_frexp_v4f32_v4i32:
 783 ; RV64I:       # %bb.0:
 784 ; RV64I-NEXT:    addi sp, sp, -64
 785 ; RV64I-NEXT:    sd ra, 56(sp) # 8-byte Folded Spill
 786 ; RV64I-NEXT:    sd s0, 48(sp) # 8-byte Folded Spill
 787 ; RV64I-NEXT:    sd s1, 40(sp) # 8-byte Folded Spill
 788 ; RV64I-NEXT:    sd s2, 32(sp) # 8-byte Folded Spill
 789 ; RV64I-NEXT:    sd s3, 24(sp) # 8-byte Folded Spill
 790 ; RV64I-NEXT:    sd s4, 16(sp) # 8-byte Folded Spill
 791 ; RV64I-NEXT:    lw s0, 24(a1)
 792 ; RV64I-NEXT:    lw s1, 16(a1)
 793 ; RV64I-NEXT:    lw s2, 8(a1)
 794 ; RV64I-NEXT:    lw a2, 0(a1)
 795 ; RV64I-NEXT:    mv s3, a0
 796 ; RV64I-NEXT:    mv a1, sp
 797 ; RV64I-NEXT:    mv a0, a2
 798 ; RV64I-NEXT:    call frexpf
 799 ; RV64I-NEXT:    mv s4, a0
 800 ; RV64I-NEXT:    addi a1, sp, 4
 801 ; RV64I-NEXT:    mv a0, s2
 802 ; RV64I-NEXT:    call frexpf
 803 ; RV64I-NEXT:    mv s2, a0
 804 ; RV64I-NEXT:    addi a1, sp, 8
 805 ; RV64I-NEXT:    mv a0, s1
 806 ; RV64I-NEXT:    call frexpf
 807 ; RV64I-NEXT:    mv s1, a0
 808 ; RV64I-NEXT:    addi a1, sp, 12
 809 ; RV64I-NEXT:    mv a0, s0
 810 ; RV64I-NEXT:    call frexpf
 811 ; RV64I-NEXT:    lw a1, 0(sp)
 812 ; RV64I-NEXT:    lw a2, 4(sp)
 813 ; RV64I-NEXT:    lw a3, 8(sp)
 814 ; RV64I-NEXT:    lw a4, 12(sp)
 815 ; RV64I-NEXT:    sw a0, 12(s3)
 816 ; RV64I-NEXT:    sw s1, 8(s3)
 817 ; RV64I-NEXT:    sw s2, 4(s3)
 818 ; RV64I-NEXT:    sw s4, 0(s3)
 819 ; RV64I-NEXT:    sw a4, 28(s3)
 820 ; RV64I-NEXT:    sw a3, 24(s3)
 821 ; RV64I-NEXT:    sw a2, 20(s3)
 822 ; RV64I-NEXT:    sw a1, 16(s3)
 823 ; RV64I-NEXT:    ld ra, 56(sp) # 8-byte Folded Reload
 824 ; RV64I-NEXT:    ld s0, 48(sp) # 8-byte Folded Reload
 825 ; RV64I-NEXT:    ld s1, 40(sp) # 8-byte Folded Reload
 826 ; RV64I-NEXT:    ld s2, 32(sp) # 8-byte Folded Reload
 827 ; RV64I-NEXT:    ld s3, 24(sp) # 8-byte Folded Reload
 828 ; RV64I-NEXT:    ld s4, 16(sp) # 8-byte Folded Reload
 829 ; RV64I-NEXT:    addi sp, sp, 64
 830 ; RV64I-NEXT:    ret
 831   %result = call { <4 x float>, <4 x i32> } @llvm.frexp.v4f32.v4i32(<4 x float> %a)
 832   ret { <4 x float>, <4 x i32> } %result
 833 }
 834
 835 define <4 x float> @test_frexp_v4f32_v4i32_only_use_fract(<4 x float> %a) nounwind {
 836 ; RV32IFD-LABEL: test_frexp_v4f32_v4i32_only_use_fract:
 837 ; RV32IFD:       # %bb.0:
 838 ; RV32IFD-NEXT:    addi sp, sp, -64
 839 ; RV32IFD-NEXT:    sw ra, 60(sp) # 4-byte Folded Spill
 840 ; RV32IFD-NEXT:    sw s0, 56(sp) # 4-byte Folded Spill
 841 ; RV32IFD-NEXT:    fsd fs0, 48(sp) # 8-byte Folded Spill
 842 ; RV32IFD-NEXT:    fsd fs1, 40(sp) # 8-byte Folded Spill
 843 ; RV32IFD-NEXT:    fsd fs2, 32(sp) # 8-byte Folded Spill
 844 ; RV32IFD-NEXT:    fsd fs3, 24(sp) # 8-byte Folded Spill
 845 ; RV32IFD-NEXT:    fmv.s fs0, fa3
 846 ; RV32IFD-NEXT:    fmv.s fs1, fa2
 847 ; RV32IFD-NEXT:    fmv.s fs2, fa1
 848 ; RV32IFD-NEXT:    mv s0, a0
 849 ; RV32IFD-NEXT:    addi a0, sp, 8
 850 ; RV32IFD-NEXT:    call frexpf
 851 ; RV32IFD-NEXT:    fmv.s fs3, fa0
 852 ; RV32IFD-NEXT:    addi a0, sp, 12
 853 ; RV32IFD-NEXT:    fmv.s fa0, fs2
 854 ; RV32IFD-NEXT:    call frexpf
 855 ; RV32IFD-NEXT:    fmv.s fs2, fa0
 856 ; RV32IFD-NEXT:    addi a0, sp, 16
 857 ; RV32IFD-NEXT:    fmv.s fa0, fs1
 858 ; RV32IFD-NEXT:    call frexpf
 859 ; RV32IFD-NEXT:    fmv.s fs1, fa0
 860 ; RV32IFD-NEXT:    addi a0, sp, 20
 861 ; RV32IFD-NEXT:    fmv.s fa0, fs0
 862 ; RV32IFD-NEXT:    call frexpf
 863 ; RV32IFD-NEXT:    fsw fa0, 12(s0)
 864 ; RV32IFD-NEXT:    fsw fs1, 8(s0)
 865 ; RV32IFD-NEXT:    fsw fs2, 4(s0)
 866 ; RV32IFD-NEXT:    fsw fs3, 0(s0)
 867 ; RV32IFD-NEXT:    lw ra, 60(sp) # 4-byte Folded Reload
 868 ; RV32IFD-NEXT:    lw s0, 56(sp) # 4-byte Folded Reload
 869 ; RV32IFD-NEXT:    fld fs0, 48(sp) # 8-byte Folded Reload
 870 ; RV32IFD-NEXT:    fld fs1, 40(sp) # 8-byte Folded Reload
 871 ; RV32IFD-NEXT:    fld fs2, 32(sp) # 8-byte Folded Reload
 872 ; RV32IFD-NEXT:    fld fs3, 24(sp) # 8-byte Folded Reload
 873 ; RV32IFD-NEXT:    addi sp, sp, 64
 874 ; RV32IFD-NEXT:    ret
 875 ;
 876 ; RV64IFD-LABEL: test_frexp_v4f32_v4i32_only_use_fract:
 877 ; RV64IFD:       # %bb.0:
 878 ; RV64IFD-NEXT:    addi sp, sp, -80
 879 ; RV64IFD-NEXT:    sd ra, 72(sp) # 8-byte Folded Spill
 880 ; RV64IFD-NEXT:    sd s0, 64(sp) # 8-byte Folded Spill
 881 ; RV64IFD-NEXT:    fsd fs0, 56(sp) # 8-byte Folded Spill
 882 ; RV64IFD-NEXT:    fsd fs1, 48(sp) # 8-byte Folded Spill
 883 ; RV64IFD-NEXT:    fsd fs2, 40(sp) # 8-byte Folded Spill
 884 ; RV64IFD-NEXT:    fsd fs3, 32(sp) # 8-byte Folded Spill
 885 ; RV64IFD-NEXT:    fmv.s fs0, fa3
 886 ; RV64IFD-NEXT:    fmv.s fs1, fa2
 887 ; RV64IFD-NEXT:    fmv.s fs2, fa1
 888 ; RV64IFD-NEXT:    mv s0, a0
 889 ; RV64IFD-NEXT:    mv a0, sp
 890 ; RV64IFD-NEXT:    call frexpf
 891 ; RV64IFD-NEXT:    fmv.s fs3, fa0
 892 ; RV64IFD-NEXT:    addi a0, sp, 8
 893 ; RV64IFD-NEXT:    fmv.s fa0, fs2
 894 ; RV64IFD-NEXT:    call frexpf
 895 ; RV64IFD-NEXT:    fmv.s fs2, fa0
 896 ; RV64IFD-NEXT:    addi a0, sp, 16
 897 ; RV64IFD-NEXT:    fmv.s fa0, fs1
 898 ; RV64IFD-NEXT:    call frexpf
 899 ; RV64IFD-NEXT:    fmv.s fs1, fa0
 900 ; RV64IFD-NEXT:    addi a0, sp, 24
 901 ; RV64IFD-NEXT:    fmv.s fa0, fs0
 902 ; RV64IFD-NEXT:    call frexpf
 903 ; RV64IFD-NEXT:    fsw fa0, 12(s0)
 904 ; RV64IFD-NEXT:    fsw fs1, 8(s0)
 905 ; RV64IFD-NEXT:    fsw fs2, 4(s0)
 906 ; RV64IFD-NEXT:    fsw fs3, 0(s0)
 907 ; RV64IFD-NEXT:    ld ra, 72(sp) # 8-byte Folded Reload
 908 ; RV64IFD-NEXT:    ld s0, 64(sp) # 8-byte Folded Reload
 909 ; RV64IFD-NEXT:    fld fs0, 56(sp) # 8-byte Folded Reload
 910 ; RV64IFD-NEXT:    fld fs1, 48(sp) # 8-byte Folded Reload
 911 ; RV64IFD-NEXT:    fld fs2, 40(sp) # 8-byte Folded Reload
 912 ; RV64IFD-NEXT:    fld fs3, 32(sp) # 8-byte Folded Reload
 913 ; RV64IFD-NEXT:    addi sp, sp, 80
 914 ; RV64IFD-NEXT:    ret
 915 ;
 916 ; RV32IZFINXZDINX-LABEL: test_frexp_v4f32_v4i32_only_use_fract:
 917 ; RV32IZFINXZDINX:       # %bb.0:
 918 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -48
 919 ; RV32IZFINXZDINX-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
 920 ; RV32IZFINXZDINX-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
 921 ; RV32IZFINXZDINX-NEXT:    sw s1, 36(sp) # 4-byte Folded Spill
 922 ; RV32IZFINXZDINX-NEXT:    sw s2, 32(sp) # 4-byte Folded Spill
 923 ; RV32IZFINXZDINX-NEXT:    sw s3, 28(sp) # 4-byte Folded Spill
 924 ; RV32IZFINXZDINX-NEXT:    sw s4, 24(sp) # 4-byte Folded Spill
 925 ; RV32IZFINXZDINX-NEXT:    mv s0, a4
 926 ; RV32IZFINXZDINX-NEXT:    mv s1, a3
 927 ; RV32IZFINXZDINX-NEXT:    mv s2, a2
 928 ; RV32IZFINXZDINX-NEXT:    mv a2, a1
 929 ; RV32IZFINXZDINX-NEXT:    mv s3, a0
 930 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 8
 931 ; RV32IZFINXZDINX-NEXT:    mv a0, a2
 932 ; RV32IZFINXZDINX-NEXT:    call frexpf
 933 ; RV32IZFINXZDINX-NEXT:    mv s4, a0
 934 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 12
 935 ; RV32IZFINXZDINX-NEXT:    mv a0, s2
 936 ; RV32IZFINXZDINX-NEXT:    call frexpf
 937 ; RV32IZFINXZDINX-NEXT:    mv s2, a0
 938 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 16
 939 ; RV32IZFINXZDINX-NEXT:    mv a0, s1
 940 ; RV32IZFINXZDINX-NEXT:    call frexpf
 941 ; RV32IZFINXZDINX-NEXT:    mv s1, a0
 942 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 20
 943 ; RV32IZFINXZDINX-NEXT:    mv a0, s0
 944 ; RV32IZFINXZDINX-NEXT:    call frexpf
 945 ; RV32IZFINXZDINX-NEXT:    sw a0, 12(s3)
 946 ; RV32IZFINXZDINX-NEXT:    sw s1, 8(s3)
 947 ; RV32IZFINXZDINX-NEXT:    sw s2, 4(s3)
 948 ; RV32IZFINXZDINX-NEXT:    sw s4, 0(s3)
 949 ; RV32IZFINXZDINX-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
 950 ; RV32IZFINXZDINX-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
 951 ; RV32IZFINXZDINX-NEXT:    lw s1, 36(sp) # 4-byte Folded Reload
 952 ; RV32IZFINXZDINX-NEXT:    lw s2, 32(sp) # 4-byte Folded Reload
 953 ; RV32IZFINXZDINX-NEXT:    lw s3, 28(sp) # 4-byte Folded Reload
 954 ; RV32IZFINXZDINX-NEXT:    lw s4, 24(sp) # 4-byte Folded Reload
 955 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 48
 956 ; RV32IZFINXZDINX-NEXT:    ret
 957 ;
 958 ; RV64IZFINXZDINX-LABEL: test_frexp_v4f32_v4i32_only_use_fract:
 959 ; RV64IZFINXZDINX:       # %bb.0:
 960 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -80
 961 ; RV64IZFINXZDINX-NEXT:    sd ra, 72(sp) # 8-byte Folded Spill
 962 ; RV64IZFINXZDINX-NEXT:    sd s0, 64(sp) # 8-byte Folded Spill
 963 ; RV64IZFINXZDINX-NEXT:    sd s1, 56(sp) # 8-byte Folded Spill
 964 ; RV64IZFINXZDINX-NEXT:    sd s2, 48(sp) # 8-byte Folded Spill
 965 ; RV64IZFINXZDINX-NEXT:    sd s3, 40(sp) # 8-byte Folded Spill
 966 ; RV64IZFINXZDINX-NEXT:    sd s4, 32(sp) # 8-byte Folded Spill
 967 ; RV64IZFINXZDINX-NEXT:    mv s0, a4
 968 ; RV64IZFINXZDINX-NEXT:    mv s1, a3
 969 ; RV64IZFINXZDINX-NEXT:    mv s2, a2
 970 ; RV64IZFINXZDINX-NEXT:    mv a2, a1
 971 ; RV64IZFINXZDINX-NEXT:    mv s3, a0
 972 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
 973 ; RV64IZFINXZDINX-NEXT:    mv a0, a2
 974 ; RV64IZFINXZDINX-NEXT:    call frexpf
 975 ; RV64IZFINXZDINX-NEXT:    mv s4, a0
 976 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 8
 977 ; RV64IZFINXZDINX-NEXT:    mv a0, s2
 978 ; RV64IZFINXZDINX-NEXT:    call frexpf
 979 ; RV64IZFINXZDINX-NEXT:    mv s2, a0
 980 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 16
 981 ; RV64IZFINXZDINX-NEXT:    mv a0, s1
 982 ; RV64IZFINXZDINX-NEXT:    call frexpf
 983 ; RV64IZFINXZDINX-NEXT:    mv s1, a0
 984 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 24
 985 ; RV64IZFINXZDINX-NEXT:    mv a0, s0
 986 ; RV64IZFINXZDINX-NEXT:    call frexpf
 987 ; RV64IZFINXZDINX-NEXT:    sw a0, 12(s3)
 988 ; RV64IZFINXZDINX-NEXT:    sw s1, 8(s3)
 989 ; RV64IZFINXZDINX-NEXT:    sw s2, 4(s3)
 990 ; RV64IZFINXZDINX-NEXT:    sw s4, 0(s3)
 991 ; RV64IZFINXZDINX-NEXT:    ld ra, 72(sp) # 8-byte Folded Reload
 992 ; RV64IZFINXZDINX-NEXT:    ld s0, 64(sp) # 8-byte Folded Reload
 993 ; RV64IZFINXZDINX-NEXT:    ld s1, 56(sp) # 8-byte Folded Reload
 994 ; RV64IZFINXZDINX-NEXT:    ld s2, 48(sp) # 8-byte Folded Reload
 995 ; RV64IZFINXZDINX-NEXT:    ld s3, 40(sp) # 8-byte Folded Reload
 996 ; RV64IZFINXZDINX-NEXT:    ld s4, 32(sp) # 8-byte Folded Reload
 997 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 80
 998 ; RV64IZFINXZDINX-NEXT:    ret
 999 ;
1000 ; RV32I-LABEL: test_frexp_v4f32_v4i32_only_use_fract:
1001 ; RV32I:       # %bb.0:
1002 ; RV32I-NEXT:    addi sp, sp, -48
1003 ; RV32I-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1004 ; RV32I-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1005 ; RV32I-NEXT:    sw s1, 36(sp) # 4-byte Folded Spill
1006 ; RV32I-NEXT:    sw s2, 32(sp) # 4-byte Folded Spill
1007 ; RV32I-NEXT:    sw s3, 28(sp) # 4-byte Folded Spill
1008 ; RV32I-NEXT:    sw s4, 24(sp) # 4-byte Folded Spill
1009 ; RV32I-NEXT:    lw s0, 12(a1)
1010 ; RV32I-NEXT:    lw s1, 8(a1)
1011 ; RV32I-NEXT:    lw s2, 4(a1)
1012 ; RV32I-NEXT:    lw a2, 0(a1)
1013 ; RV32I-NEXT:    mv s3, a0
1014 ; RV32I-NEXT:    addi a1, sp, 8
1015 ; RV32I-NEXT:    mv a0, a2
1016 ; RV32I-NEXT:    call frexpf
1017 ; RV32I-NEXT:    mv s4, a0
1018 ; RV32I-NEXT:    addi a1, sp, 12
1019 ; RV32I-NEXT:    mv a0, s2
1020 ; RV32I-NEXT:    call frexpf
1021 ; RV32I-NEXT:    mv s2, a0
1022 ; RV32I-NEXT:    addi a1, sp, 16
1023 ; RV32I-NEXT:    mv a0, s1
1024 ; RV32I-NEXT:    call frexpf
1025 ; RV32I-NEXT:    mv s1, a0
1026 ; RV32I-NEXT:    addi a1, sp, 20
1027 ; RV32I-NEXT:    mv a0, s0
1028 ; RV32I-NEXT:    call frexpf
1029 ; RV32I-NEXT:    sw a0, 12(s3)
1030 ; RV32I-NEXT:    sw s1, 8(s3)
1031 ; RV32I-NEXT:    sw s2, 4(s3)
1032 ; RV32I-NEXT:    sw s4, 0(s3)
1033 ; RV32I-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1034 ; RV32I-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1035 ; RV32I-NEXT:    lw s1, 36(sp) # 4-byte Folded Reload
1036 ; RV32I-NEXT:    lw s2, 32(sp) # 4-byte Folded Reload
1037 ; RV32I-NEXT:    lw s3, 28(sp) # 4-byte Folded Reload
1038 ; RV32I-NEXT:    lw s4, 24(sp) # 4-byte Folded Reload
1039 ; RV32I-NEXT:    addi sp, sp, 48
1040 ; RV32I-NEXT:    ret
1041 ;
1042 ; RV64I-LABEL: test_frexp_v4f32_v4i32_only_use_fract:
1043 ; RV64I:       # %bb.0:
1044 ; RV64I-NEXT:    addi sp, sp, -64
1045 ; RV64I-NEXT:    sd ra, 56(sp) # 8-byte Folded Spill
1046 ; RV64I-NEXT:    sd s0, 48(sp) # 8-byte Folded Spill
1047 ; RV64I-NEXT:    sd s1, 40(sp) # 8-byte Folded Spill
1048 ; RV64I-NEXT:    sd s2, 32(sp) # 8-byte Folded Spill
1049 ; RV64I-NEXT:    sd s3, 24(sp) # 8-byte Folded Spill
1050 ; RV64I-NEXT:    sd s4, 16(sp) # 8-byte Folded Spill
1051 ; RV64I-NEXT:    lw s0, 24(a1)
1052 ; RV64I-NEXT:    lw s1, 16(a1)
1053 ; RV64I-NEXT:    lw s2, 8(a1)
1054 ; RV64I-NEXT:    lw a2, 0(a1)
1055 ; RV64I-NEXT:    mv s3, a0
1056 ; RV64I-NEXT:    mv a1, sp
1057 ; RV64I-NEXT:    mv a0, a2
1058 ; RV64I-NEXT:    call frexpf
1059 ; RV64I-NEXT:    mv s4, a0
1060 ; RV64I-NEXT:    addi a1, sp, 4
1061 ; RV64I-NEXT:    mv a0, s2
1062 ; RV64I-NEXT:    call frexpf
1063 ; RV64I-NEXT:    mv s2, a0
1064 ; RV64I-NEXT:    addi a1, sp, 8
1065 ; RV64I-NEXT:    mv a0, s1
1066 ; RV64I-NEXT:    call frexpf
1067 ; RV64I-NEXT:    mv s1, a0
1068 ; RV64I-NEXT:    addi a1, sp, 12
1069 ; RV64I-NEXT:    mv a0, s0
1070 ; RV64I-NEXT:    call frexpf
1071 ; RV64I-NEXT:    sw a0, 12(s3)
1072 ; RV64I-NEXT:    sw s1, 8(s3)
1073 ; RV64I-NEXT:    sw s2, 4(s3)
1074 ; RV64I-NEXT:    sw s4, 0(s3)
1075 ; RV64I-NEXT:    ld ra, 56(sp) # 8-byte Folded Reload
1076 ; RV64I-NEXT:    ld s0, 48(sp) # 8-byte Folded Reload
1077 ; RV64I-NEXT:    ld s1, 40(sp) # 8-byte Folded Reload
1078 ; RV64I-NEXT:    ld s2, 32(sp) # 8-byte Folded Reload
1079 ; RV64I-NEXT:    ld s3, 24(sp) # 8-byte Folded Reload
1080 ; RV64I-NEXT:    ld s4, 16(sp) # 8-byte Folded Reload
1081 ; RV64I-NEXT:    addi sp, sp, 64
1082 ; RV64I-NEXT:    ret
1083   %result = call { <4 x float>, <4 x i32> } @llvm.frexp.v4f32.v4i32(<4 x float> %a)
1084   %result.0 = extractvalue { <4 x float>, <4 x i32> } %result, 0
1085   ret <4 x float> %result.0
1086 }
1087
1088 define <4 x i32> @test_frexp_v4f32_v4i32_only_use_exp(<4 x float> %a) nounwind {
1089 ; RV32IFD-LABEL: test_frexp_v4f32_v4i32_only_use_exp:
1090 ; RV32IFD:       # %bb.0:
1091 ; RV32IFD-NEXT:    addi sp, sp, -48
1092 ; RV32IFD-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1093 ; RV32IFD-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1094 ; RV32IFD-NEXT:    fsd fs0, 32(sp) # 8-byte Folded Spill
1095 ; RV32IFD-NEXT:    fsd fs1, 24(sp) # 8-byte Folded Spill
1096 ; RV32IFD-NEXT:    fsd fs2, 16(sp) # 8-byte Folded Spill
1097 ; RV32IFD-NEXT:    fmv.s fs0, fa3
1098 ; RV32IFD-NEXT:    fmv.s fs1, fa2
1099 ; RV32IFD-NEXT:    fmv.s fs2, fa1
1100 ; RV32IFD-NEXT:    mv s0, a0
1101 ; RV32IFD-NEXT:    mv a0, sp
1102 ; RV32IFD-NEXT:    call frexpf
1103 ; RV32IFD-NEXT:    addi a0, sp, 4
1104 ; RV32IFD-NEXT:    fmv.s fa0, fs2
1105 ; RV32IFD-NEXT:    call frexpf
1106 ; RV32IFD-NEXT:    addi a0, sp, 8
1107 ; RV32IFD-NEXT:    fmv.s fa0, fs1
1108 ; RV32IFD-NEXT:    call frexpf
1109 ; RV32IFD-NEXT:    addi a0, sp, 12
1110 ; RV32IFD-NEXT:    fmv.s fa0, fs0
1111 ; RV32IFD-NEXT:    call frexpf
1112 ; RV32IFD-NEXT:    lw a0, 12(sp)
1113 ; RV32IFD-NEXT:    lw a1, 8(sp)
1114 ; RV32IFD-NEXT:    lw a2, 4(sp)
1115 ; RV32IFD-NEXT:    lw a3, 0(sp)
1116 ; RV32IFD-NEXT:    sw a0, 12(s0)
1117 ; RV32IFD-NEXT:    sw a1, 8(s0)
1118 ; RV32IFD-NEXT:    sw a2, 4(s0)
1119 ; RV32IFD-NEXT:    sw a3, 0(s0)
1120 ; RV32IFD-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1121 ; RV32IFD-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1122 ; RV32IFD-NEXT:    fld fs0, 32(sp) # 8-byte Folded Reload
1123 ; RV32IFD-NEXT:    fld fs1, 24(sp) # 8-byte Folded Reload
1124 ; RV32IFD-NEXT:    fld fs2, 16(sp) # 8-byte Folded Reload
1125 ; RV32IFD-NEXT:    addi sp, sp, 48
1126 ; RV32IFD-NEXT:    ret
1127 ;
1128 ; RV64IFD-LABEL: test_frexp_v4f32_v4i32_only_use_exp:
1129 ; RV64IFD:       # %bb.0:
1130 ; RV64IFD-NEXT:    addi sp, sp, -80
1131 ; RV64IFD-NEXT:    sd ra, 72(sp) # 8-byte Folded Spill
1132 ; RV64IFD-NEXT:    sd s0, 64(sp) # 8-byte Folded Spill
1133 ; RV64IFD-NEXT:    fsd fs0, 56(sp) # 8-byte Folded Spill
1134 ; RV64IFD-NEXT:    fsd fs1, 48(sp) # 8-byte Folded Spill
1135 ; RV64IFD-NEXT:    fsd fs2, 40(sp) # 8-byte Folded Spill
1136 ; RV64IFD-NEXT:    fmv.s fs0, fa3
1137 ; RV64IFD-NEXT:    fmv.s fs1, fa2
1138 ; RV64IFD-NEXT:    fmv.s fs2, fa1
1139 ; RV64IFD-NEXT:    mv s0, a0
1140 ; RV64IFD-NEXT:    addi a0, sp, 8
1141 ; RV64IFD-NEXT:    call frexpf
1142 ; RV64IFD-NEXT:    addi a0, sp, 16
1143 ; RV64IFD-NEXT:    fmv.s fa0, fs2
1144 ; RV64IFD-NEXT:    call frexpf
1145 ; RV64IFD-NEXT:    addi a0, sp, 24
1146 ; RV64IFD-NEXT:    fmv.s fa0, fs1
1147 ; RV64IFD-NEXT:    call frexpf
1148 ; RV64IFD-NEXT:    addi a0, sp, 32
1149 ; RV64IFD-NEXT:    fmv.s fa0, fs0
1150 ; RV64IFD-NEXT:    call frexpf
1151 ; RV64IFD-NEXT:    ld a0, 32(sp)
1152 ; RV64IFD-NEXT:    ld a1, 24(sp)
1153 ; RV64IFD-NEXT:    ld a2, 16(sp)
1154 ; RV64IFD-NEXT:    ld a3, 8(sp)
1155 ; RV64IFD-NEXT:    sw a0, 12(s0)
1156 ; RV64IFD-NEXT:    sw a1, 8(s0)
1157 ; RV64IFD-NEXT:    sw a2, 4(s0)
1158 ; RV64IFD-NEXT:    sw a3, 0(s0)
1159 ; RV64IFD-NEXT:    ld ra, 72(sp) # 8-byte Folded Reload
1160 ; RV64IFD-NEXT:    ld s0, 64(sp) # 8-byte Folded Reload
1161 ; RV64IFD-NEXT:    fld fs0, 56(sp) # 8-byte Folded Reload
1162 ; RV64IFD-NEXT:    fld fs1, 48(sp) # 8-byte Folded Reload
1163 ; RV64IFD-NEXT:    fld fs2, 40(sp) # 8-byte Folded Reload
1164 ; RV64IFD-NEXT:    addi sp, sp, 80
1165 ; RV64IFD-NEXT:    ret
1166 ;
1167 ; RV32IZFINXZDINX-LABEL: test_frexp_v4f32_v4i32_only_use_exp:
1168 ; RV32IZFINXZDINX:       # %bb.0:
1169 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -48
1170 ; RV32IZFINXZDINX-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1171 ; RV32IZFINXZDINX-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1172 ; RV32IZFINXZDINX-NEXT:    sw s1, 36(sp) # 4-byte Folded Spill
1173 ; RV32IZFINXZDINX-NEXT:    sw s2, 32(sp) # 4-byte Folded Spill
1174 ; RV32IZFINXZDINX-NEXT:    sw s3, 28(sp) # 4-byte Folded Spill
1175 ; RV32IZFINXZDINX-NEXT:    mv s0, a4
1176 ; RV32IZFINXZDINX-NEXT:    mv s1, a3
1177 ; RV32IZFINXZDINX-NEXT:    mv s2, a2
1178 ; RV32IZFINXZDINX-NEXT:    mv a2, a1
1179 ; RV32IZFINXZDINX-NEXT:    mv s3, a0
1180 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 12
1181 ; RV32IZFINXZDINX-NEXT:    mv a0, a2
1182 ; RV32IZFINXZDINX-NEXT:    call frexpf
1183 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 16
1184 ; RV32IZFINXZDINX-NEXT:    mv a0, s2
1185 ; RV32IZFINXZDINX-NEXT:    call frexpf
1186 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 20
1187 ; RV32IZFINXZDINX-NEXT:    mv a0, s1
1188 ; RV32IZFINXZDINX-NEXT:    call frexpf
1189 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 24
1190 ; RV32IZFINXZDINX-NEXT:    mv a0, s0
1191 ; RV32IZFINXZDINX-NEXT:    call frexpf
1192 ; RV32IZFINXZDINX-NEXT:    lw a0, 24(sp)
1193 ; RV32IZFINXZDINX-NEXT:    lw a1, 20(sp)
1194 ; RV32IZFINXZDINX-NEXT:    lw a2, 16(sp)
1195 ; RV32IZFINXZDINX-NEXT:    lw a3, 12(sp)
1196 ; RV32IZFINXZDINX-NEXT:    sw a0, 12(s3)
1197 ; RV32IZFINXZDINX-NEXT:    sw a1, 8(s3)
1198 ; RV32IZFINXZDINX-NEXT:    sw a2, 4(s3)
1199 ; RV32IZFINXZDINX-NEXT:    sw a3, 0(s3)
1200 ; RV32IZFINXZDINX-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1201 ; RV32IZFINXZDINX-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1202 ; RV32IZFINXZDINX-NEXT:    lw s1, 36(sp) # 4-byte Folded Reload
1203 ; RV32IZFINXZDINX-NEXT:    lw s2, 32(sp) # 4-byte Folded Reload
1204 ; RV32IZFINXZDINX-NEXT:    lw s3, 28(sp) # 4-byte Folded Reload
1205 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 48
1206 ; RV32IZFINXZDINX-NEXT:    ret
1207 ;
1208 ; RV64IZFINXZDINX-LABEL: test_frexp_v4f32_v4i32_only_use_exp:
1209 ; RV64IZFINXZDINX:       # %bb.0:
1210 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -80
1211 ; RV64IZFINXZDINX-NEXT:    sd ra, 72(sp) # 8-byte Folded Spill
1212 ; RV64IZFINXZDINX-NEXT:    sd s0, 64(sp) # 8-byte Folded Spill
1213 ; RV64IZFINXZDINX-NEXT:    sd s1, 56(sp) # 8-byte Folded Spill
1214 ; RV64IZFINXZDINX-NEXT:    sd s2, 48(sp) # 8-byte Folded Spill
1215 ; RV64IZFINXZDINX-NEXT:    sd s3, 40(sp) # 8-byte Folded Spill
1216 ; RV64IZFINXZDINX-NEXT:    mv s0, a4
1217 ; RV64IZFINXZDINX-NEXT:    mv s1, a3
1218 ; RV64IZFINXZDINX-NEXT:    mv s2, a2
1219 ; RV64IZFINXZDINX-NEXT:    mv a2, a1
1220 ; RV64IZFINXZDINX-NEXT:    mv s3, a0
1221 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 8
1222 ; RV64IZFINXZDINX-NEXT:    mv a0, a2
1223 ; RV64IZFINXZDINX-NEXT:    call frexpf
1224 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 16
1225 ; RV64IZFINXZDINX-NEXT:    mv a0, s2
1226 ; RV64IZFINXZDINX-NEXT:    call frexpf
1227 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 24
1228 ; RV64IZFINXZDINX-NEXT:    mv a0, s1
1229 ; RV64IZFINXZDINX-NEXT:    call frexpf
1230 ; RV64IZFINXZDINX-NEXT:    addi a1, sp, 32
1231 ; RV64IZFINXZDINX-NEXT:    mv a0, s0
1232 ; RV64IZFINXZDINX-NEXT:    call frexpf
1233 ; RV64IZFINXZDINX-NEXT:    ld a0, 32(sp)
1234 ; RV64IZFINXZDINX-NEXT:    ld a1, 24(sp)
1235 ; RV64IZFINXZDINX-NEXT:    ld a2, 16(sp)
1236 ; RV64IZFINXZDINX-NEXT:    ld a3, 8(sp)
1237 ; RV64IZFINXZDINX-NEXT:    sw a0, 12(s3)
1238 ; RV64IZFINXZDINX-NEXT:    sw a1, 8(s3)
1239 ; RV64IZFINXZDINX-NEXT:    sw a2, 4(s3)
1240 ; RV64IZFINXZDINX-NEXT:    sw a3, 0(s3)
1241 ; RV64IZFINXZDINX-NEXT:    ld ra, 72(sp) # 8-byte Folded Reload
1242 ; RV64IZFINXZDINX-NEXT:    ld s0, 64(sp) # 8-byte Folded Reload
1243 ; RV64IZFINXZDINX-NEXT:    ld s1, 56(sp) # 8-byte Folded Reload
1244 ; RV64IZFINXZDINX-NEXT:    ld s2, 48(sp) # 8-byte Folded Reload
1245 ; RV64IZFINXZDINX-NEXT:    ld s3, 40(sp) # 8-byte Folded Reload
1246 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 80
1247 ; RV64IZFINXZDINX-NEXT:    ret
1248 ;
1249 ; RV32I-LABEL: test_frexp_v4f32_v4i32_only_use_exp:
1250 ; RV32I:       # %bb.0:
1251 ; RV32I-NEXT:    addi sp, sp, -48
1252 ; RV32I-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1253 ; RV32I-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1254 ; RV32I-NEXT:    sw s1, 36(sp) # 4-byte Folded Spill
1255 ; RV32I-NEXT:    sw s2, 32(sp) # 4-byte Folded Spill
1256 ; RV32I-NEXT:    sw s3, 28(sp) # 4-byte Folded Spill
1257 ; RV32I-NEXT:    lw s0, 12(a1)
1258 ; RV32I-NEXT:    lw s1, 8(a1)
1259 ; RV32I-NEXT:    lw s2, 4(a1)
1260 ; RV32I-NEXT:    lw a2, 0(a1)
1261 ; RV32I-NEXT:    mv s3, a0
1262 ; RV32I-NEXT:    addi a1, sp, 12
1263 ; RV32I-NEXT:    mv a0, a2
1264 ; RV32I-NEXT:    call frexpf
1265 ; RV32I-NEXT:    addi a1, sp, 16
1266 ; RV32I-NEXT:    mv a0, s2
1267 ; RV32I-NEXT:    call frexpf
1268 ; RV32I-NEXT:    addi a1, sp, 20
1269 ; RV32I-NEXT:    mv a0, s1
1270 ; RV32I-NEXT:    call frexpf
1271 ; RV32I-NEXT:    addi a1, sp, 24
1272 ; RV32I-NEXT:    mv a0, s0
1273 ; RV32I-NEXT:    call frexpf
1274 ; RV32I-NEXT:    lw a0, 24(sp)
1275 ; RV32I-NEXT:    lw a1, 20(sp)
1276 ; RV32I-NEXT:    lw a2, 16(sp)
1277 ; RV32I-NEXT:    lw a3, 12(sp)
1278 ; RV32I-NEXT:    sw a0, 12(s3)
1279 ; RV32I-NEXT:    sw a1, 8(s3)
1280 ; RV32I-NEXT:    sw a2, 4(s3)
1281 ; RV32I-NEXT:    sw a3, 0(s3)
1282 ; RV32I-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1283 ; RV32I-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1284 ; RV32I-NEXT:    lw s1, 36(sp) # 4-byte Folded Reload
1285 ; RV32I-NEXT:    lw s2, 32(sp) # 4-byte Folded Reload
1286 ; RV32I-NEXT:    lw s3, 28(sp) # 4-byte Folded Reload
1287 ; RV32I-NEXT:    addi sp, sp, 48
1288 ; RV32I-NEXT:    ret
1289 ;
1290 ; RV64I-LABEL: test_frexp_v4f32_v4i32_only_use_exp:
1291 ; RV64I:       # %bb.0:
1292 ; RV64I-NEXT:    addi sp, sp, -64
1293 ; RV64I-NEXT:    sd ra, 56(sp) # 8-byte Folded Spill
1294 ; RV64I-NEXT:    sd s0, 48(sp) # 8-byte Folded Spill
1295 ; RV64I-NEXT:    sd s1, 40(sp) # 8-byte Folded Spill
1296 ; RV64I-NEXT:    sd s2, 32(sp) # 8-byte Folded Spill
1297 ; RV64I-NEXT:    sd s3, 24(sp) # 8-byte Folded Spill
1298 ; RV64I-NEXT:    lw s0, 24(a1)
1299 ; RV64I-NEXT:    lw s1, 16(a1)
1300 ; RV64I-NEXT:    lw s2, 8(a1)
1301 ; RV64I-NEXT:    lw a2, 0(a1)
1302 ; RV64I-NEXT:    mv s3, a0
1303 ; RV64I-NEXT:    addi a1, sp, 8
1304 ; RV64I-NEXT:    mv a0, a2
1305 ; RV64I-NEXT:    call frexpf
1306 ; RV64I-NEXT:    addi a1, sp, 12
1307 ; RV64I-NEXT:    mv a0, s2
1308 ; RV64I-NEXT:    call frexpf
1309 ; RV64I-NEXT:    addi a1, sp, 16
1310 ; RV64I-NEXT:    mv a0, s1
1311 ; RV64I-NEXT:    call frexpf
1312 ; RV64I-NEXT:    addi a1, sp, 20
1313 ; RV64I-NEXT:    mv a0, s0
1314 ; RV64I-NEXT:    call frexpf
1315 ; RV64I-NEXT:    lw a0, 20(sp)
1316 ; RV64I-NEXT:    lw a1, 16(sp)
1317 ; RV64I-NEXT:    lw a2, 12(sp)
1318 ; RV64I-NEXT:    lw a3, 8(sp)
1319 ; RV64I-NEXT:    sw a0, 12(s3)
1320 ; RV64I-NEXT:    sw a1, 8(s3)
1321 ; RV64I-NEXT:    sw a2, 4(s3)
1322 ; RV64I-NEXT:    sw a3, 0(s3)
1323 ; RV64I-NEXT:    ld ra, 56(sp) # 8-byte Folded Reload
1324 ; RV64I-NEXT:    ld s0, 48(sp) # 8-byte Folded Reload
1325 ; RV64I-NEXT:    ld s1, 40(sp) # 8-byte Folded Reload
1326 ; RV64I-NEXT:    ld s2, 32(sp) # 8-byte Folded Reload
1327 ; RV64I-NEXT:    ld s3, 24(sp) # 8-byte Folded Reload
1328 ; RV64I-NEXT:    addi sp, sp, 64
1329 ; RV64I-NEXT:    ret
1330   %result = call { <4 x float>, <4 x i32> } @llvm.frexp.v4f32.v4i32(<4 x float> %a)
1331   %result.1 = extractvalue { <4 x float>, <4 x i32> } %result, 1
1332   ret <4 x i32> %result.1
1333 }
1334
1335 define { double, i32 } @test_frexp_f64_i32(double %a) nounwind {
1336 ; RV32IFD-LABEL: test_frexp_f64_i32:
1337 ; RV32IFD:       # %bb.0:
1338 ; RV32IFD-NEXT:    addi sp, sp, -16
1339 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1340 ; RV32IFD-NEXT:    addi a0, sp, 8
1341 ; RV32IFD-NEXT:    call frexp
1342 ; RV32IFD-NEXT:    lw a0, 8(sp)
1343 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1344 ; RV32IFD-NEXT:    addi sp, sp, 16
1345 ; RV32IFD-NEXT:    ret
1346 ;
1347 ; RV64IFD-LABEL: test_frexp_f64_i32:
1348 ; RV64IFD:       # %bb.0:
1349 ; RV64IFD-NEXT:    addi sp, sp, -16
1350 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1351 ; RV64IFD-NEXT:    mv a0, sp
1352 ; RV64IFD-NEXT:    call frexp
1353 ; RV64IFD-NEXT:    ld a0, 0(sp)
1354 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1355 ; RV64IFD-NEXT:    addi sp, sp, 16
1356 ; RV64IFD-NEXT:    ret
1357 ;
1358 ; RV32IZFINXZDINX-LABEL: test_frexp_f64_i32:
1359 ; RV32IZFINXZDINX:       # %bb.0:
1360 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1361 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1362 ; RV32IZFINXZDINX-NEXT:    addi a2, sp, 8
1363 ; RV32IZFINXZDINX-NEXT:    call frexp
1364 ; RV32IZFINXZDINX-NEXT:    lw a2, 8(sp)
1365 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1366 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1367 ; RV32IZFINXZDINX-NEXT:    ret
1368 ;
1369 ; RV64IZFINXZDINX-LABEL: test_frexp_f64_i32:
1370 ; RV64IZFINXZDINX:       # %bb.0:
1371 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
1372 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1373 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
1374 ; RV64IZFINXZDINX-NEXT:    call frexp
1375 ; RV64IZFINXZDINX-NEXT:    ld a1, 0(sp)
1376 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1377 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
1378 ; RV64IZFINXZDINX-NEXT:    ret
1379 ;
1380 ; RV32I-LABEL: test_frexp_f64_i32:
1381 ; RV32I:       # %bb.0:
1382 ; RV32I-NEXT:    addi sp, sp, -16
1383 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1384 ; RV32I-NEXT:    sw s0, 8(sp) # 4-byte Folded Spill
1385 ; RV32I-NEXT:    mv a3, a2
1386 ; RV32I-NEXT:    mv s0, a0
1387 ; RV32I-NEXT:    addi a2, sp, 4
1388 ; RV32I-NEXT:    mv a0, a1
1389 ; RV32I-NEXT:    mv a1, a3
1390 ; RV32I-NEXT:    call frexp
1391 ; RV32I-NEXT:    lw a2, 4(sp)
1392 ; RV32I-NEXT:    sw a1, 4(s0)
1393 ; RV32I-NEXT:    sw a0, 0(s0)
1394 ; RV32I-NEXT:    sw a2, 8(s0)
1395 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1396 ; RV32I-NEXT:    lw s0, 8(sp) # 4-byte Folded Reload
1397 ; RV32I-NEXT:    addi sp, sp, 16
1398 ; RV32I-NEXT:    ret
1399 ;
1400 ; RV64I-LABEL: test_frexp_f64_i32:
1401 ; RV64I:       # %bb.0:
1402 ; RV64I-NEXT:    addi sp, sp, -16
1403 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1404 ; RV64I-NEXT:    addi a1, sp, 4
1405 ; RV64I-NEXT:    call frexp
1406 ; RV64I-NEXT:    lw a1, 4(sp)
1407 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1408 ; RV64I-NEXT:    addi sp, sp, 16
1409 ; RV64I-NEXT:    ret
1410   %result = call { double, i32 } @llvm.frexp.f64.i32(double %a)
1411   ret { double, i32 } %result
1412 }
1413
1414 define double @test_frexp_f64_i32_only_use_fract(double %a) nounwind {
1415 ; RV32IFD-LABEL: test_frexp_f64_i32_only_use_fract:
1416 ; RV32IFD:       # %bb.0:
1417 ; RV32IFD-NEXT:    addi sp, sp, -16
1418 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1419 ; RV32IFD-NEXT:    addi a0, sp, 8
1420 ; RV32IFD-NEXT:    call frexp
1421 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1422 ; RV32IFD-NEXT:    addi sp, sp, 16
1423 ; RV32IFD-NEXT:    ret
1424 ;
1425 ; RV64IFD-LABEL: test_frexp_f64_i32_only_use_fract:
1426 ; RV64IFD:       # %bb.0:
1427 ; RV64IFD-NEXT:    addi sp, sp, -16
1428 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1429 ; RV64IFD-NEXT:    mv a0, sp
1430 ; RV64IFD-NEXT:    call frexp
1431 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1432 ; RV64IFD-NEXT:    addi sp, sp, 16
1433 ; RV64IFD-NEXT:    ret
1434 ;
1435 ; RV32IZFINXZDINX-LABEL: test_frexp_f64_i32_only_use_fract:
1436 ; RV32IZFINXZDINX:       # %bb.0:
1437 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1438 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1439 ; RV32IZFINXZDINX-NEXT:    addi a2, sp, 8
1440 ; RV32IZFINXZDINX-NEXT:    call frexp
1441 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1442 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1443 ; RV32IZFINXZDINX-NEXT:    ret
1444 ;
1445 ; RV64IZFINXZDINX-LABEL: test_frexp_f64_i32_only_use_fract:
1446 ; RV64IZFINXZDINX:       # %bb.0:
1447 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
1448 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1449 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
1450 ; RV64IZFINXZDINX-NEXT:    call frexp
1451 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1452 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
1453 ; RV64IZFINXZDINX-NEXT:    ret
1454 ;
1455 ; RV32I-LABEL: test_frexp_f64_i32_only_use_fract:
1456 ; RV32I:       # %bb.0:
1457 ; RV32I-NEXT:    addi sp, sp, -16
1458 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1459 ; RV32I-NEXT:    addi a2, sp, 8
1460 ; RV32I-NEXT:    call frexp
1461 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1462 ; RV32I-NEXT:    addi sp, sp, 16
1463 ; RV32I-NEXT:    ret
1464 ;
1465 ; RV64I-LABEL: test_frexp_f64_i32_only_use_fract:
1466 ; RV64I:       # %bb.0:
1467 ; RV64I-NEXT:    addi sp, sp, -16
1468 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1469 ; RV64I-NEXT:    addi a1, sp, 4
1470 ; RV64I-NEXT:    call frexp
1471 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1472 ; RV64I-NEXT:    addi sp, sp, 16
1473 ; RV64I-NEXT:    ret
1474   %result = call { double, i32 } @llvm.frexp.f64.i32(double %a)
1475   %result.0 = extractvalue { double, i32 } %result, 0
1476   ret double %result.0
1477 }
1478
1479 define i32 @test_frexp_f64_i32_only_use_exp(double %a) nounwind {
1480 ; RV32IFD-LABEL: test_frexp_f64_i32_only_use_exp:
1481 ; RV32IFD:       # %bb.0:
1482 ; RV32IFD-NEXT:    addi sp, sp, -16
1483 ; RV32IFD-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1484 ; RV32IFD-NEXT:    addi a0, sp, 8
1485 ; RV32IFD-NEXT:    call frexp
1486 ; RV32IFD-NEXT:    lw a0, 8(sp)
1487 ; RV32IFD-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1488 ; RV32IFD-NEXT:    addi sp, sp, 16
1489 ; RV32IFD-NEXT:    ret
1490 ;
1491 ; RV64IFD-LABEL: test_frexp_f64_i32_only_use_exp:
1492 ; RV64IFD:       # %bb.0:
1493 ; RV64IFD-NEXT:    addi sp, sp, -16
1494 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1495 ; RV64IFD-NEXT:    mv a0, sp
1496 ; RV64IFD-NEXT:    call frexp
1497 ; RV64IFD-NEXT:    ld a0, 0(sp)
1498 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1499 ; RV64IFD-NEXT:    addi sp, sp, 16
1500 ; RV64IFD-NEXT:    ret
1501 ;
1502 ; RV32IZFINXZDINX-LABEL: test_frexp_f64_i32_only_use_exp:
1503 ; RV32IZFINXZDINX:       # %bb.0:
1504 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -16
1505 ; RV32IZFINXZDINX-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1506 ; RV32IZFINXZDINX-NEXT:    addi a2, sp, 8
1507 ; RV32IZFINXZDINX-NEXT:    call frexp
1508 ; RV32IZFINXZDINX-NEXT:    lw a0, 8(sp)
1509 ; RV32IZFINXZDINX-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1510 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 16
1511 ; RV32IZFINXZDINX-NEXT:    ret
1512 ;
1513 ; RV64IZFINXZDINX-LABEL: test_frexp_f64_i32_only_use_exp:
1514 ; RV64IZFINXZDINX:       # %bb.0:
1515 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
1516 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1517 ; RV64IZFINXZDINX-NEXT:    mv a1, sp
1518 ; RV64IZFINXZDINX-NEXT:    call frexp
1519 ; RV64IZFINXZDINX-NEXT:    ld a0, 0(sp)
1520 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1521 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
1522 ; RV64IZFINXZDINX-NEXT:    ret
1523 ;
1524 ; RV32I-LABEL: test_frexp_f64_i32_only_use_exp:
1525 ; RV32I:       # %bb.0:
1526 ; RV32I-NEXT:    addi sp, sp, -16
1527 ; RV32I-NEXT:    sw ra, 12(sp) # 4-byte Folded Spill
1528 ; RV32I-NEXT:    addi a2, sp, 8
1529 ; RV32I-NEXT:    call frexp
1530 ; RV32I-NEXT:    lw a0, 8(sp)
1531 ; RV32I-NEXT:    lw ra, 12(sp) # 4-byte Folded Reload
1532 ; RV32I-NEXT:    addi sp, sp, 16
1533 ; RV32I-NEXT:    ret
1534 ;
1535 ; RV64I-LABEL: test_frexp_f64_i32_only_use_exp:
1536 ; RV64I:       # %bb.0:
1537 ; RV64I-NEXT:    addi sp, sp, -16
1538 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1539 ; RV64I-NEXT:    addi a1, sp, 4
1540 ; RV64I-NEXT:    call frexp
1541 ; RV64I-NEXT:    lw a0, 4(sp)
1542 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1543 ; RV64I-NEXT:    addi sp, sp, 16
1544 ; RV64I-NEXT:    ret
1545   %result = call { double, i32 } @llvm.frexp.f64.i32(double %a)
1546   %result.0 = extractvalue { double, i32 } %result, 1
1547   ret i32 %result.0
1548 }
1549
1550 ; FIXME: Widen vector result
1551 ; define { <2 x double>, <2 x i32> } @test_frexp_v2f64_v2i32(<2 x double> %a) nounwind {
1552 ;   %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a)
1553 ;   ret { <2 x double>, <2 x i32> } %result
1554 ; }
1555
1556 ; define <2 x double> @test_frexp_v2f64_v2i32_only_use_fract(<2 x double> %a) nounwind {
1557 ;   %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a)
1558 ;   %result.0 = extractvalue { <2 x double>, <2 x i32> } %result, 0
1559 ;   ret <2 x double> %result.0
1560 ; }
1561
1562 ; define <2 x i32> @test_frexp_v2f64_v2i32_only_use_exp(<2 x double> %a) nounwind {
1563 ;   %result = call { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double> %a)
1564 ;   %result.1 = extractvalue { <2 x double>, <2 x i32> } %result, 1
1565 ;   ret <2 x i32> %result.1
1566 ; }
1567
1568 define { fp128, i32 } @test_frexp_f128_i32(fp128 %a) nounwind {
1569 ; RV32IFD-LABEL: test_frexp_f128_i32:
1570 ; RV32IFD:       # %bb.0:
1571 ; RV32IFD-NEXT:    addi sp, sp, -48
1572 ; RV32IFD-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1573 ; RV32IFD-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1574 ; RV32IFD-NEXT:    lw a3, 0(a1)
1575 ; RV32IFD-NEXT:    lw a2, 4(a1)
1576 ; RV32IFD-NEXT:    lw a4, 8(a1)
1577 ; RV32IFD-NEXT:    lw a1, 12(a1)
1578 ; RV32IFD-NEXT:    mv s0, a0
1579 ; RV32IFD-NEXT:    sw a1, 12(sp)
1580 ; RV32IFD-NEXT:    sw a4, 8(sp)
1581 ; RV32IFD-NEXT:    sw a2, 4(sp)
1582 ; RV32IFD-NEXT:    addi a0, sp, 16
1583 ; RV32IFD-NEXT:    mv a1, sp
1584 ; RV32IFD-NEXT:    addi a2, sp, 36
1585 ; RV32IFD-NEXT:    sw a3, 0(sp)
1586 ; RV32IFD-NEXT:    call frexpl
1587 ; RV32IFD-NEXT:    lw a0, 36(sp)
1588 ; RV32IFD-NEXT:    lw a1, 28(sp)
1589 ; RV32IFD-NEXT:    lw a2, 24(sp)
1590 ; RV32IFD-NEXT:    lw a3, 20(sp)
1591 ; RV32IFD-NEXT:    lw a4, 16(sp)
1592 ; RV32IFD-NEXT:    sw a1, 12(s0)
1593 ; RV32IFD-NEXT:    sw a2, 8(s0)
1594 ; RV32IFD-NEXT:    sw a3, 4(s0)
1595 ; RV32IFD-NEXT:    sw a4, 0(s0)
1596 ; RV32IFD-NEXT:    sw a0, 16(s0)
1597 ; RV32IFD-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1598 ; RV32IFD-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1599 ; RV32IFD-NEXT:    addi sp, sp, 48
1600 ; RV32IFD-NEXT:    ret
1601 ;
1602 ; RV64IFD-LABEL: test_frexp_f128_i32:
1603 ; RV64IFD:       # %bb.0:
1604 ; RV64IFD-NEXT:    addi sp, sp, -32
1605 ; RV64IFD-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
1606 ; RV64IFD-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
1607 ; RV64IFD-NEXT:    mv a3, a2
1608 ; RV64IFD-NEXT:    mv s0, a0
1609 ; RV64IFD-NEXT:    addi a2, sp, 12
1610 ; RV64IFD-NEXT:    mv a0, a1
1611 ; RV64IFD-NEXT:    mv a1, a3
1612 ; RV64IFD-NEXT:    call frexpl
1613 ; RV64IFD-NEXT:    lw a2, 12(sp)
1614 ; RV64IFD-NEXT:    sd a1, 8(s0)
1615 ; RV64IFD-NEXT:    sd a0, 0(s0)
1616 ; RV64IFD-NEXT:    sw a2, 16(s0)
1617 ; RV64IFD-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
1618 ; RV64IFD-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
1619 ; RV64IFD-NEXT:    addi sp, sp, 32
1620 ; RV64IFD-NEXT:    ret
1621 ;
1622 ; RV32IZFINXZDINX-LABEL: test_frexp_f128_i32:
1623 ; RV32IZFINXZDINX:       # %bb.0:
1624 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -48
1625 ; RV32IZFINXZDINX-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1626 ; RV32IZFINXZDINX-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1627 ; RV32IZFINXZDINX-NEXT:    lw a3, 0(a1)
1628 ; RV32IZFINXZDINX-NEXT:    lw a2, 4(a1)
1629 ; RV32IZFINXZDINX-NEXT:    lw a4, 8(a1)
1630 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(a1)
1631 ; RV32IZFINXZDINX-NEXT:    mv s0, a0
1632 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
1633 ; RV32IZFINXZDINX-NEXT:    sw a4, 8(sp)
1634 ; RV32IZFINXZDINX-NEXT:    sw a2, 4(sp)
1635 ; RV32IZFINXZDINX-NEXT:    addi a0, sp, 16
1636 ; RV32IZFINXZDINX-NEXT:    mv a1, sp
1637 ; RV32IZFINXZDINX-NEXT:    addi a2, sp, 36
1638 ; RV32IZFINXZDINX-NEXT:    sw a3, 0(sp)
1639 ; RV32IZFINXZDINX-NEXT:    call frexpl
1640 ; RV32IZFINXZDINX-NEXT:    lw a0, 36(sp)
1641 ; RV32IZFINXZDINX-NEXT:    lw a1, 28(sp)
1642 ; RV32IZFINXZDINX-NEXT:    lw a2, 24(sp)
1643 ; RV32IZFINXZDINX-NEXT:    lw a3, 20(sp)
1644 ; RV32IZFINXZDINX-NEXT:    lw a4, 16(sp)
1645 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(s0)
1646 ; RV32IZFINXZDINX-NEXT:    sw a2, 8(s0)
1647 ; RV32IZFINXZDINX-NEXT:    sw a3, 4(s0)
1648 ; RV32IZFINXZDINX-NEXT:    sw a4, 0(s0)
1649 ; RV32IZFINXZDINX-NEXT:    sw a0, 16(s0)
1650 ; RV32IZFINXZDINX-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1651 ; RV32IZFINXZDINX-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1652 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 48
1653 ; RV32IZFINXZDINX-NEXT:    ret
1654 ;
1655 ; RV64IZFINXZDINX-LABEL: test_frexp_f128_i32:
1656 ; RV64IZFINXZDINX:       # %bb.0:
1657 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -32
1658 ; RV64IZFINXZDINX-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
1659 ; RV64IZFINXZDINX-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
1660 ; RV64IZFINXZDINX-NEXT:    mv a3, a2
1661 ; RV64IZFINXZDINX-NEXT:    mv s0, a0
1662 ; RV64IZFINXZDINX-NEXT:    addi a2, sp, 12
1663 ; RV64IZFINXZDINX-NEXT:    mv a0, a1
1664 ; RV64IZFINXZDINX-NEXT:    mv a1, a3
1665 ; RV64IZFINXZDINX-NEXT:    call frexpl
1666 ; RV64IZFINXZDINX-NEXT:    lw a2, 12(sp)
1667 ; RV64IZFINXZDINX-NEXT:    sd a1, 8(s0)
1668 ; RV64IZFINXZDINX-NEXT:    sd a0, 0(s0)
1669 ; RV64IZFINXZDINX-NEXT:    sw a2, 16(s0)
1670 ; RV64IZFINXZDINX-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
1671 ; RV64IZFINXZDINX-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
1672 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 32
1673 ; RV64IZFINXZDINX-NEXT:    ret
1674 ;
1675 ; RV32I-LABEL: test_frexp_f128_i32:
1676 ; RV32I:       # %bb.0:
1677 ; RV32I-NEXT:    addi sp, sp, -48
1678 ; RV32I-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1679 ; RV32I-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1680 ; RV32I-NEXT:    lw a3, 0(a1)
1681 ; RV32I-NEXT:    lw a2, 4(a1)
1682 ; RV32I-NEXT:    lw a4, 8(a1)
1683 ; RV32I-NEXT:    lw a1, 12(a1)
1684 ; RV32I-NEXT:    mv s0, a0
1685 ; RV32I-NEXT:    sw a1, 12(sp)
1686 ; RV32I-NEXT:    sw a4, 8(sp)
1687 ; RV32I-NEXT:    sw a2, 4(sp)
1688 ; RV32I-NEXT:    addi a0, sp, 16
1689 ; RV32I-NEXT:    mv a1, sp
1690 ; RV32I-NEXT:    addi a2, sp, 36
1691 ; RV32I-NEXT:    sw a3, 0(sp)
1692 ; RV32I-NEXT:    call frexpl
1693 ; RV32I-NEXT:    lw a0, 36(sp)
1694 ; RV32I-NEXT:    lw a1, 28(sp)
1695 ; RV32I-NEXT:    lw a2, 24(sp)
1696 ; RV32I-NEXT:    lw a3, 20(sp)
1697 ; RV32I-NEXT:    lw a4, 16(sp)
1698 ; RV32I-NEXT:    sw a1, 12(s0)
1699 ; RV32I-NEXT:    sw a2, 8(s0)
1700 ; RV32I-NEXT:    sw a3, 4(s0)
1701 ; RV32I-NEXT:    sw a4, 0(s0)
1702 ; RV32I-NEXT:    sw a0, 16(s0)
1703 ; RV32I-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1704 ; RV32I-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1705 ; RV32I-NEXT:    addi sp, sp, 48
1706 ; RV32I-NEXT:    ret
1707 ;
1708 ; RV64I-LABEL: test_frexp_f128_i32:
1709 ; RV64I:       # %bb.0:
1710 ; RV64I-NEXT:    addi sp, sp, -32
1711 ; RV64I-NEXT:    sd ra, 24(sp) # 8-byte Folded Spill
1712 ; RV64I-NEXT:    sd s0, 16(sp) # 8-byte Folded Spill
1713 ; RV64I-NEXT:    mv a3, a2
1714 ; RV64I-NEXT:    mv s0, a0
1715 ; RV64I-NEXT:    addi a2, sp, 12
1716 ; RV64I-NEXT:    mv a0, a1
1717 ; RV64I-NEXT:    mv a1, a3
1718 ; RV64I-NEXT:    call frexpl
1719 ; RV64I-NEXT:    lw a2, 12(sp)
1720 ; RV64I-NEXT:    sd a1, 8(s0)
1721 ; RV64I-NEXT:    sd a0, 0(s0)
1722 ; RV64I-NEXT:    sw a2, 16(s0)
1723 ; RV64I-NEXT:    ld ra, 24(sp) # 8-byte Folded Reload
1724 ; RV64I-NEXT:    ld s0, 16(sp) # 8-byte Folded Reload
1725 ; RV64I-NEXT:    addi sp, sp, 32
1726 ; RV64I-NEXT:    ret
1727   %result = call { fp128, i32 } @llvm.frexp.f128.i32(fp128 %a)
1728   ret { fp128, i32 } %result
1729 }
1730
1731 define fp128 @test_frexp_f128_i32_only_use_fract(fp128 %a) nounwind {
1732 ; RV32IFD-LABEL: test_frexp_f128_i32_only_use_fract:
1733 ; RV32IFD:       # %bb.0:
1734 ; RV32IFD-NEXT:    addi sp, sp, -48
1735 ; RV32IFD-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1736 ; RV32IFD-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1737 ; RV32IFD-NEXT:    lw a3, 0(a1)
1738 ; RV32IFD-NEXT:    lw a2, 4(a1)
1739 ; RV32IFD-NEXT:    lw a4, 8(a1)
1740 ; RV32IFD-NEXT:    lw a1, 12(a1)
1741 ; RV32IFD-NEXT:    mv s0, a0
1742 ; RV32IFD-NEXT:    sw a1, 12(sp)
1743 ; RV32IFD-NEXT:    sw a4, 8(sp)
1744 ; RV32IFD-NEXT:    sw a2, 4(sp)
1745 ; RV32IFD-NEXT:    addi a0, sp, 16
1746 ; RV32IFD-NEXT:    mv a1, sp
1747 ; RV32IFD-NEXT:    addi a2, sp, 36
1748 ; RV32IFD-NEXT:    sw a3, 0(sp)
1749 ; RV32IFD-NEXT:    call frexpl
1750 ; RV32IFD-NEXT:    lw a0, 28(sp)
1751 ; RV32IFD-NEXT:    lw a1, 24(sp)
1752 ; RV32IFD-NEXT:    lw a2, 20(sp)
1753 ; RV32IFD-NEXT:    lw a3, 16(sp)
1754 ; RV32IFD-NEXT:    sw a0, 12(s0)
1755 ; RV32IFD-NEXT:    sw a1, 8(s0)
1756 ; RV32IFD-NEXT:    sw a2, 4(s0)
1757 ; RV32IFD-NEXT:    sw a3, 0(s0)
1758 ; RV32IFD-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1759 ; RV32IFD-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1760 ; RV32IFD-NEXT:    addi sp, sp, 48
1761 ; RV32IFD-NEXT:    ret
1762 ;
1763 ; RV64IFD-LABEL: test_frexp_f128_i32_only_use_fract:
1764 ; RV64IFD:       # %bb.0:
1765 ; RV64IFD-NEXT:    addi sp, sp, -16
1766 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1767 ; RV64IFD-NEXT:    addi a2, sp, 4
1768 ; RV64IFD-NEXT:    call frexpl
1769 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1770 ; RV64IFD-NEXT:    addi sp, sp, 16
1771 ; RV64IFD-NEXT:    ret
1772 ;
1773 ; RV32IZFINXZDINX-LABEL: test_frexp_f128_i32_only_use_fract:
1774 ; RV32IZFINXZDINX:       # %bb.0:
1775 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -48
1776 ; RV32IZFINXZDINX-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1777 ; RV32IZFINXZDINX-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1778 ; RV32IZFINXZDINX-NEXT:    lw a3, 0(a1)
1779 ; RV32IZFINXZDINX-NEXT:    lw a2, 4(a1)
1780 ; RV32IZFINXZDINX-NEXT:    lw a4, 8(a1)
1781 ; RV32IZFINXZDINX-NEXT:    lw a1, 12(a1)
1782 ; RV32IZFINXZDINX-NEXT:    mv s0, a0
1783 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
1784 ; RV32IZFINXZDINX-NEXT:    sw a4, 8(sp)
1785 ; RV32IZFINXZDINX-NEXT:    sw a2, 4(sp)
1786 ; RV32IZFINXZDINX-NEXT:    addi a0, sp, 16
1787 ; RV32IZFINXZDINX-NEXT:    mv a1, sp
1788 ; RV32IZFINXZDINX-NEXT:    addi a2, sp, 36
1789 ; RV32IZFINXZDINX-NEXT:    sw a3, 0(sp)
1790 ; RV32IZFINXZDINX-NEXT:    call frexpl
1791 ; RV32IZFINXZDINX-NEXT:    lw a0, 28(sp)
1792 ; RV32IZFINXZDINX-NEXT:    lw a1, 24(sp)
1793 ; RV32IZFINXZDINX-NEXT:    lw a2, 20(sp)
1794 ; RV32IZFINXZDINX-NEXT:    lw a3, 16(sp)
1795 ; RV32IZFINXZDINX-NEXT:    sw a0, 12(s0)
1796 ; RV32IZFINXZDINX-NEXT:    sw a1, 8(s0)
1797 ; RV32IZFINXZDINX-NEXT:    sw a2, 4(s0)
1798 ; RV32IZFINXZDINX-NEXT:    sw a3, 0(s0)
1799 ; RV32IZFINXZDINX-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1800 ; RV32IZFINXZDINX-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1801 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 48
1802 ; RV32IZFINXZDINX-NEXT:    ret
1803 ;
1804 ; RV64IZFINXZDINX-LABEL: test_frexp_f128_i32_only_use_fract:
1805 ; RV64IZFINXZDINX:       # %bb.0:
1806 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
1807 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1808 ; RV64IZFINXZDINX-NEXT:    addi a2, sp, 4
1809 ; RV64IZFINXZDINX-NEXT:    call frexpl
1810 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1811 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
1812 ; RV64IZFINXZDINX-NEXT:    ret
1813 ;
1814 ; RV32I-LABEL: test_frexp_f128_i32_only_use_fract:
1815 ; RV32I:       # %bb.0:
1816 ; RV32I-NEXT:    addi sp, sp, -48
1817 ; RV32I-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1818 ; RV32I-NEXT:    sw s0, 40(sp) # 4-byte Folded Spill
1819 ; RV32I-NEXT:    lw a3, 0(a1)
1820 ; RV32I-NEXT:    lw a2, 4(a1)
1821 ; RV32I-NEXT:    lw a4, 8(a1)
1822 ; RV32I-NEXT:    lw a1, 12(a1)
1823 ; RV32I-NEXT:    mv s0, a0
1824 ; RV32I-NEXT:    sw a1, 12(sp)
1825 ; RV32I-NEXT:    sw a4, 8(sp)
1826 ; RV32I-NEXT:    sw a2, 4(sp)
1827 ; RV32I-NEXT:    addi a0, sp, 16
1828 ; RV32I-NEXT:    mv a1, sp
1829 ; RV32I-NEXT:    addi a2, sp, 36
1830 ; RV32I-NEXT:    sw a3, 0(sp)
1831 ; RV32I-NEXT:    call frexpl
1832 ; RV32I-NEXT:    lw a0, 28(sp)
1833 ; RV32I-NEXT:    lw a1, 24(sp)
1834 ; RV32I-NEXT:    lw a2, 20(sp)
1835 ; RV32I-NEXT:    lw a3, 16(sp)
1836 ; RV32I-NEXT:    sw a0, 12(s0)
1837 ; RV32I-NEXT:    sw a1, 8(s0)
1838 ; RV32I-NEXT:    sw a2, 4(s0)
1839 ; RV32I-NEXT:    sw a3, 0(s0)
1840 ; RV32I-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1841 ; RV32I-NEXT:    lw s0, 40(sp) # 4-byte Folded Reload
1842 ; RV32I-NEXT:    addi sp, sp, 48
1843 ; RV32I-NEXT:    ret
1844 ;
1845 ; RV64I-LABEL: test_frexp_f128_i32_only_use_fract:
1846 ; RV64I:       # %bb.0:
1847 ; RV64I-NEXT:    addi sp, sp, -16
1848 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1849 ; RV64I-NEXT:    addi a2, sp, 4
1850 ; RV64I-NEXT:    call frexpl
1851 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1852 ; RV64I-NEXT:    addi sp, sp, 16
1853 ; RV64I-NEXT:    ret
1854   %result = call { fp128, i32 } @llvm.frexp.f128.i32(fp128 %a)
1855   %result.0 = extractvalue { fp128, i32 } %result, 0
1856   ret fp128 %result.0
1857 }
1858
1859 define i32 @test_frexp_f128_i32_only_use_exp(fp128 %a) nounwind {
1860 ; RV32IFD-LABEL: test_frexp_f128_i32_only_use_exp:
1861 ; RV32IFD:       # %bb.0:
1862 ; RV32IFD-NEXT:    addi sp, sp, -48
1863 ; RV32IFD-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1864 ; RV32IFD-NEXT:    lw a3, 0(a0)
1865 ; RV32IFD-NEXT:    lw a1, 4(a0)
1866 ; RV32IFD-NEXT:    lw a2, 8(a0)
1867 ; RV32IFD-NEXT:    lw a0, 12(a0)
1868 ; RV32IFD-NEXT:    sw a0, 20(sp)
1869 ; RV32IFD-NEXT:    sw a2, 16(sp)
1870 ; RV32IFD-NEXT:    sw a1, 12(sp)
1871 ; RV32IFD-NEXT:    addi a0, sp, 24
1872 ; RV32IFD-NEXT:    addi a1, sp, 8
1873 ; RV32IFD-NEXT:    addi a2, sp, 40
1874 ; RV32IFD-NEXT:    sw a3, 8(sp)
1875 ; RV32IFD-NEXT:    call frexpl
1876 ; RV32IFD-NEXT:    lw a0, 40(sp)
1877 ; RV32IFD-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1878 ; RV32IFD-NEXT:    addi sp, sp, 48
1879 ; RV32IFD-NEXT:    ret
1880 ;
1881 ; RV64IFD-LABEL: test_frexp_f128_i32_only_use_exp:
1882 ; RV64IFD:       # %bb.0:
1883 ; RV64IFD-NEXT:    addi sp, sp, -16
1884 ; RV64IFD-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1885 ; RV64IFD-NEXT:    addi a2, sp, 4
1886 ; RV64IFD-NEXT:    call frexpl
1887 ; RV64IFD-NEXT:    lw a0, 4(sp)
1888 ; RV64IFD-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1889 ; RV64IFD-NEXT:    addi sp, sp, 16
1890 ; RV64IFD-NEXT:    ret
1891 ;
1892 ; RV32IZFINXZDINX-LABEL: test_frexp_f128_i32_only_use_exp:
1893 ; RV32IZFINXZDINX:       # %bb.0:
1894 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, -48
1895 ; RV32IZFINXZDINX-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1896 ; RV32IZFINXZDINX-NEXT:    lw a3, 0(a0)
1897 ; RV32IZFINXZDINX-NEXT:    lw a1, 4(a0)
1898 ; RV32IZFINXZDINX-NEXT:    lw a2, 8(a0)
1899 ; RV32IZFINXZDINX-NEXT:    lw a0, 12(a0)
1900 ; RV32IZFINXZDINX-NEXT:    sw a0, 20(sp)
1901 ; RV32IZFINXZDINX-NEXT:    sw a2, 16(sp)
1902 ; RV32IZFINXZDINX-NEXT:    sw a1, 12(sp)
1903 ; RV32IZFINXZDINX-NEXT:    addi a0, sp, 24
1904 ; RV32IZFINXZDINX-NEXT:    addi a1, sp, 8
1905 ; RV32IZFINXZDINX-NEXT:    addi a2, sp, 40
1906 ; RV32IZFINXZDINX-NEXT:    sw a3, 8(sp)
1907 ; RV32IZFINXZDINX-NEXT:    call frexpl
1908 ; RV32IZFINXZDINX-NEXT:    lw a0, 40(sp)
1909 ; RV32IZFINXZDINX-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1910 ; RV32IZFINXZDINX-NEXT:    addi sp, sp, 48
1911 ; RV32IZFINXZDINX-NEXT:    ret
1912 ;
1913 ; RV64IZFINXZDINX-LABEL: test_frexp_f128_i32_only_use_exp:
1914 ; RV64IZFINXZDINX:       # %bb.0:
1915 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, -16
1916 ; RV64IZFINXZDINX-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1917 ; RV64IZFINXZDINX-NEXT:    addi a2, sp, 4
1918 ; RV64IZFINXZDINX-NEXT:    call frexpl
1919 ; RV64IZFINXZDINX-NEXT:    lw a0, 4(sp)
1920 ; RV64IZFINXZDINX-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1921 ; RV64IZFINXZDINX-NEXT:    addi sp, sp, 16
1922 ; RV64IZFINXZDINX-NEXT:    ret
1923 ;
1924 ; RV32I-LABEL: test_frexp_f128_i32_only_use_exp:
1925 ; RV32I:       # %bb.0:
1926 ; RV32I-NEXT:    addi sp, sp, -48
1927 ; RV32I-NEXT:    sw ra, 44(sp) # 4-byte Folded Spill
1928 ; RV32I-NEXT:    lw a3, 0(a0)
1929 ; RV32I-NEXT:    lw a1, 4(a0)
1930 ; RV32I-NEXT:    lw a2, 8(a0)
1931 ; RV32I-NEXT:    lw a0, 12(a0)
1932 ; RV32I-NEXT:    sw a0, 20(sp)
1933 ; RV32I-NEXT:    sw a2, 16(sp)
1934 ; RV32I-NEXT:    sw a1, 12(sp)
1935 ; RV32I-NEXT:    addi a0, sp, 24
1936 ; RV32I-NEXT:    addi a1, sp, 8
1937 ; RV32I-NEXT:    addi a2, sp, 40
1938 ; RV32I-NEXT:    sw a3, 8(sp)
1939 ; RV32I-NEXT:    call frexpl
1940 ; RV32I-NEXT:    lw a0, 40(sp)
1941 ; RV32I-NEXT:    lw ra, 44(sp) # 4-byte Folded Reload
1942 ; RV32I-NEXT:    addi sp, sp, 48
1943 ; RV32I-NEXT:    ret
1944 ;
1945 ; RV64I-LABEL: test_frexp_f128_i32_only_use_exp:
1946 ; RV64I:       # %bb.0:
1947 ; RV64I-NEXT:    addi sp, sp, -16
1948 ; RV64I-NEXT:    sd ra, 8(sp) # 8-byte Folded Spill
1949 ; RV64I-NEXT:    addi a2, sp, 4
1950 ; RV64I-NEXT:    call frexpl
1951 ; RV64I-NEXT:    lw a0, 4(sp)
1952 ; RV64I-NEXT:    ld ra, 8(sp) # 8-byte Folded Reload
1953 ; RV64I-NEXT:    addi sp, sp, 16
1954 ; RV64I-NEXT:    ret
1955   %result = call { fp128, i32 } @llvm.frexp.f128.i32(fp128 %a)
1956   %result.0 = extractvalue { fp128, i32 } %result, 1
1957   ret i32 %result.0
1958 }
1959
1960 declare { float, i32 } @llvm.frexp.f32.i32(float) #0
1961 declare { <2 x float>, <2 x i32> } @llvm.frexp.v2f32.v2i32(<2 x float>) #0
1962 declare { <4 x float>, <4 x i32> } @llvm.frexp.v4f32.v4i32(<4 x float>) #0
1963
1964 declare { half, i32 } @llvm.frexp.f16.i32(half) #0
1965 declare { <2 x half>, <2 x i32> } @llvm.frexp.v2f16.v2i32(<2 x half>) #0
1966
1967 declare { double, i32 } @llvm.frexp.f64.i32(double) #0
1968 declare { <2 x double>, <2 x i32> } @llvm.frexp.v2f64.v2i32(<2 x double>) #0
1969
1970 declare { half, i16 } @llvm.frexp.f16.i16(half) #0
1971 declare { <2 x half>, <2 x i16> } @llvm.frexp.v2f16.v2i16(<2 x half>) #0
1972
1973 declare { fp128, i32 } @llvm.frexp.f128.i32(fp128) #0
1974
1975 attributes #0 = { nocallback nofree nosync nounwind speculatable willreturn memory(none) }