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