xref: /llvm-project/llvm/test/CodeGen/RISCV/inline-asm-f-abi-names.ll (revision e28b6a60bc02d61e50e0da545f337ea482b10240)
1856d5c58SSam Elliott; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
2856d5c58SSam Elliott; RUN: llc -mtriple=riscv32 -mattr=+f -target-abi ilp32f -verify-machineinstrs < %s \
3856d5c58SSam Elliott; RUN:   | FileCheck -check-prefix=RV32IF %s
4856d5c58SSam Elliott; RUN: llc -mtriple=riscv64 -mattr=+f -target-abi lp64f -verify-machineinstrs < %s \
5856d5c58SSam Elliott; RUN:   | FileCheck -check-prefix=RV64IF %s
6856d5c58SSam Elliott
7856d5c58SSam Elliott; These test that we can use both the architectural names (x*) and the ABI names
8856d5c58SSam Elliott; (a*, s*, t* etc) to refer to registers in inline asm constraint lists. In each
9856d5c58SSam Elliott; case, the named register should be used for the source register of the `addi`.
10856d5c58SSam Elliott; It is very likely that `a0` will be chosen as the designation register, but
11856d5c58SSam Elliott; this is left to the compiler to choose.
12856d5c58SSam Elliott;
13856d5c58SSam Elliott; The inline assembly will, by default, contain the ABI names for the registers.
14856d5c58SSam Elliott;
15856d5c58SSam Elliott; Parenthesised registers in comments are the other aliases for this register.
16856d5c58SSam Elliott
17856d5c58SSam Elliott
18856d5c58SSam Elliottdefine i32 @explicit_register_f0(float %a) nounwind {
19856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f0:
20856d5c58SSam Elliott; RV32IF:       # %bb.0:
21856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft0, fa0
22856d5c58SSam Elliott; RV32IF-NEXT:    #APP
23856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft0
24856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
25856d5c58SSam Elliott; RV32IF-NEXT:    ret
26856d5c58SSam Elliott;
27856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f0:
28856d5c58SSam Elliott; RV64IF:       # %bb.0:
29856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft0, fa0
30856d5c58SSam Elliott; RV64IF-NEXT:    #APP
31856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft0
32856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
33856d5c58SSam Elliott; RV64IF-NEXT:    ret
34856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f0}"(float %a)
35856d5c58SSam Elliott  ret i32 %1
36856d5c58SSam Elliott}
37856d5c58SSam Elliott
38856d5c58SSam Elliottdefine i32 @explicit_register_ft0(float %a) nounwind {
39856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft0:
40856d5c58SSam Elliott; RV32IF:       # %bb.0:
41856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft0, fa0
42856d5c58SSam Elliott; RV32IF-NEXT:    #APP
43856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft0
44856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
45856d5c58SSam Elliott; RV32IF-NEXT:    ret
46856d5c58SSam Elliott;
47856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft0:
48856d5c58SSam Elliott; RV64IF:       # %bb.0:
49856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft0, fa0
50856d5c58SSam Elliott; RV64IF-NEXT:    #APP
51856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft0
52856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
53856d5c58SSam Elliott; RV64IF-NEXT:    ret
54856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft0}"(float %a)
55856d5c58SSam Elliott  ret i32 %1
56856d5c58SSam Elliott}
57856d5c58SSam Elliott
58856d5c58SSam Elliottdefine i32 @explicit_register_f1(float %a) nounwind {
59856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f1:
60856d5c58SSam Elliott; RV32IF:       # %bb.0:
61856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft1, fa0
62856d5c58SSam Elliott; RV32IF-NEXT:    #APP
63856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft1
64856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
65856d5c58SSam Elliott; RV32IF-NEXT:    ret
66856d5c58SSam Elliott;
67856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f1:
68856d5c58SSam Elliott; RV64IF:       # %bb.0:
69856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft1, fa0
70856d5c58SSam Elliott; RV64IF-NEXT:    #APP
71856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft1
72856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
73856d5c58SSam Elliott; RV64IF-NEXT:    ret
74856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f1}"(float %a)
75856d5c58SSam Elliott  ret i32 %1
76856d5c58SSam Elliott}
77856d5c58SSam Elliott
78856d5c58SSam Elliottdefine i32 @explicit_register_ft1(float %a) nounwind {
79856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft1:
80856d5c58SSam Elliott; RV32IF:       # %bb.0:
81856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft1, fa0
82856d5c58SSam Elliott; RV32IF-NEXT:    #APP
83856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft1
84856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
85856d5c58SSam Elliott; RV32IF-NEXT:    ret
86856d5c58SSam Elliott;
87856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft1:
88856d5c58SSam Elliott; RV64IF:       # %bb.0:
89856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft1, fa0
90856d5c58SSam Elliott; RV64IF-NEXT:    #APP
91856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft1
92856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
93856d5c58SSam Elliott; RV64IF-NEXT:    ret
94856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft1}"(float %a)
95856d5c58SSam Elliott  ret i32 %1
96856d5c58SSam Elliott}
97856d5c58SSam Elliott
98856d5c58SSam Elliottdefine i32 @explicit_register_f2(float %a) nounwind {
99856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f2:
100856d5c58SSam Elliott; RV32IF:       # %bb.0:
101856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft2, fa0
102856d5c58SSam Elliott; RV32IF-NEXT:    #APP
103856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft2
104856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
105856d5c58SSam Elliott; RV32IF-NEXT:    ret
106856d5c58SSam Elliott;
107856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f2:
108856d5c58SSam Elliott; RV64IF:       # %bb.0:
109856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft2, fa0
110856d5c58SSam Elliott; RV64IF-NEXT:    #APP
111856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft2
112856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
113856d5c58SSam Elliott; RV64IF-NEXT:    ret
114856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f2}"(float %a)
115856d5c58SSam Elliott  ret i32 %1
116856d5c58SSam Elliott}
117856d5c58SSam Elliott
118856d5c58SSam Elliottdefine i32 @explicit_register_ft2(float %a) nounwind {
119856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft2:
120856d5c58SSam Elliott; RV32IF:       # %bb.0:
121856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft2, fa0
122856d5c58SSam Elliott; RV32IF-NEXT:    #APP
123856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft2
124856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
125856d5c58SSam Elliott; RV32IF-NEXT:    ret
126856d5c58SSam Elliott;
127856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft2:
128856d5c58SSam Elliott; RV64IF:       # %bb.0:
129856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft2, fa0
130856d5c58SSam Elliott; RV64IF-NEXT:    #APP
131856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft2
132856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
133856d5c58SSam Elliott; RV64IF-NEXT:    ret
134856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft2}"(float %a)
135856d5c58SSam Elliott  ret i32 %1
136856d5c58SSam Elliott}
137856d5c58SSam Elliott
138856d5c58SSam Elliottdefine i32 @explicit_register_f3(float %a) nounwind {
139856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f3:
140856d5c58SSam Elliott; RV32IF:       # %bb.0:
141856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft3, fa0
142856d5c58SSam Elliott; RV32IF-NEXT:    #APP
143856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft3
144856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
145856d5c58SSam Elliott; RV32IF-NEXT:    ret
146856d5c58SSam Elliott;
147856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f3:
148856d5c58SSam Elliott; RV64IF:       # %bb.0:
149856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft3, fa0
150856d5c58SSam Elliott; RV64IF-NEXT:    #APP
151856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft3
152856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
153856d5c58SSam Elliott; RV64IF-NEXT:    ret
154856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f3}"(float %a)
155856d5c58SSam Elliott  ret i32 %1
156856d5c58SSam Elliott}
157856d5c58SSam Elliott
158856d5c58SSam Elliottdefine i32 @explicit_register_ft3(float %a) nounwind {
159856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft3:
160856d5c58SSam Elliott; RV32IF:       # %bb.0:
161856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft3, fa0
162856d5c58SSam Elliott; RV32IF-NEXT:    #APP
163856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft3
164856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
165856d5c58SSam Elliott; RV32IF-NEXT:    ret
166856d5c58SSam Elliott;
167856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft3:
168856d5c58SSam Elliott; RV64IF:       # %bb.0:
169856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft3, fa0
170856d5c58SSam Elliott; RV64IF-NEXT:    #APP
171856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft3
172856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
173856d5c58SSam Elliott; RV64IF-NEXT:    ret
174856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft3}"(float %a)
175856d5c58SSam Elliott  ret i32 %1
176856d5c58SSam Elliott}
177856d5c58SSam Elliott
178856d5c58SSam Elliottdefine i32 @explicit_register_f4(float %a) nounwind {
179856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f4:
180856d5c58SSam Elliott; RV32IF:       # %bb.0:
181856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft4, fa0
182856d5c58SSam Elliott; RV32IF-NEXT:    #APP
183856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft4
184856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
185856d5c58SSam Elliott; RV32IF-NEXT:    ret
186856d5c58SSam Elliott;
187856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f4:
188856d5c58SSam Elliott; RV64IF:       # %bb.0:
189856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft4, fa0
190856d5c58SSam Elliott; RV64IF-NEXT:    #APP
191856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft4
192856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
193856d5c58SSam Elliott; RV64IF-NEXT:    ret
194856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f4}"(float %a)
195856d5c58SSam Elliott  ret i32 %1
196856d5c58SSam Elliott}
197856d5c58SSam Elliott
198856d5c58SSam Elliottdefine i32 @explicit_register_ft4(float %a) nounwind {
199856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft4:
200856d5c58SSam Elliott; RV32IF:       # %bb.0:
201856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft4, fa0
202856d5c58SSam Elliott; RV32IF-NEXT:    #APP
203856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft4
204856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
205856d5c58SSam Elliott; RV32IF-NEXT:    ret
206856d5c58SSam Elliott;
207856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft4:
208856d5c58SSam Elliott; RV64IF:       # %bb.0:
209856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft4, fa0
210856d5c58SSam Elliott; RV64IF-NEXT:    #APP
211856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft4
212856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
213856d5c58SSam Elliott; RV64IF-NEXT:    ret
214856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft4}"(float %a)
215856d5c58SSam Elliott  ret i32 %1
216856d5c58SSam Elliott}
217856d5c58SSam Elliott
218856d5c58SSam Elliottdefine i32 @explicit_register_f5(float %a) nounwind {
219856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f5:
220856d5c58SSam Elliott; RV32IF:       # %bb.0:
221856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft5, fa0
222856d5c58SSam Elliott; RV32IF-NEXT:    #APP
223856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft5
224856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
225856d5c58SSam Elliott; RV32IF-NEXT:    ret
226856d5c58SSam Elliott;
227856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f5:
228856d5c58SSam Elliott; RV64IF:       # %bb.0:
229856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft5, fa0
230856d5c58SSam Elliott; RV64IF-NEXT:    #APP
231856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft5
232856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
233856d5c58SSam Elliott; RV64IF-NEXT:    ret
234856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f5}"(float %a)
235856d5c58SSam Elliott  ret i32 %1
236856d5c58SSam Elliott}
237856d5c58SSam Elliott
238856d5c58SSam Elliottdefine i32 @explicit_register_ft5(float %a) nounwind {
239856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft5:
240856d5c58SSam Elliott; RV32IF:       # %bb.0:
241856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft5, fa0
242856d5c58SSam Elliott; RV32IF-NEXT:    #APP
243856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft5
244856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
245856d5c58SSam Elliott; RV32IF-NEXT:    ret
246856d5c58SSam Elliott;
247856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft5:
248856d5c58SSam Elliott; RV64IF:       # %bb.0:
249856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft5, fa0
250856d5c58SSam Elliott; RV64IF-NEXT:    #APP
251856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft5
252856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
253856d5c58SSam Elliott; RV64IF-NEXT:    ret
254856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft5}"(float %a)
255856d5c58SSam Elliott  ret i32 %1
256856d5c58SSam Elliott}
257856d5c58SSam Elliott
258856d5c58SSam Elliottdefine i32 @explicit_register_f6(float %a) nounwind {
259856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f6:
260856d5c58SSam Elliott; RV32IF:       # %bb.0:
261856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft6, fa0
262856d5c58SSam Elliott; RV32IF-NEXT:    #APP
263856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft6
264856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
265856d5c58SSam Elliott; RV32IF-NEXT:    ret
266856d5c58SSam Elliott;
267856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f6:
268856d5c58SSam Elliott; RV64IF:       # %bb.0:
269856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft6, fa0
270856d5c58SSam Elliott; RV64IF-NEXT:    #APP
271856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft6
272856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
273856d5c58SSam Elliott; RV64IF-NEXT:    ret
274856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f6}"(float %a)
275856d5c58SSam Elliott  ret i32 %1
276856d5c58SSam Elliott}
277856d5c58SSam Elliott
278856d5c58SSam Elliottdefine i32 @explicit_register_ft6(float %a) nounwind {
279856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft6:
280856d5c58SSam Elliott; RV32IF:       # %bb.0:
281856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft6, fa0
282856d5c58SSam Elliott; RV32IF-NEXT:    #APP
283856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft6
284856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
285856d5c58SSam Elliott; RV32IF-NEXT:    ret
286856d5c58SSam Elliott;
287856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft6:
288856d5c58SSam Elliott; RV64IF:       # %bb.0:
289856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft6, fa0
290856d5c58SSam Elliott; RV64IF-NEXT:    #APP
291856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft6
292856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
293856d5c58SSam Elliott; RV64IF-NEXT:    ret
294856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft6}"(float %a)
295856d5c58SSam Elliott  ret i32 %1
296856d5c58SSam Elliott}
297856d5c58SSam Elliott
298856d5c58SSam Elliottdefine i32 @explicit_register_f7(float %a) nounwind {
299856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f7:
300856d5c58SSam Elliott; RV32IF:       # %bb.0:
301856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft7, fa0
302856d5c58SSam Elliott; RV32IF-NEXT:    #APP
303856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft7
304856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
305856d5c58SSam Elliott; RV32IF-NEXT:    ret
306856d5c58SSam Elliott;
307856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f7:
308856d5c58SSam Elliott; RV64IF:       # %bb.0:
309856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft7, fa0
310856d5c58SSam Elliott; RV64IF-NEXT:    #APP
311856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft7
312856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
313856d5c58SSam Elliott; RV64IF-NEXT:    ret
314856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f7}"(float %a)
315856d5c58SSam Elliott  ret i32 %1
316856d5c58SSam Elliott}
317856d5c58SSam Elliott
318856d5c58SSam Elliottdefine i32 @explicit_register_ft7(float %a) nounwind {
319856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft7:
320856d5c58SSam Elliott; RV32IF:       # %bb.0:
321856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft7, fa0
322856d5c58SSam Elliott; RV32IF-NEXT:    #APP
323856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft7
324856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
325856d5c58SSam Elliott; RV32IF-NEXT:    ret
326856d5c58SSam Elliott;
327856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft7:
328856d5c58SSam Elliott; RV64IF:       # %bb.0:
329856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft7, fa0
330856d5c58SSam Elliott; RV64IF-NEXT:    #APP
331856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft7
332856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
333856d5c58SSam Elliott; RV64IF-NEXT:    ret
334856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft7}"(float %a)
335856d5c58SSam Elliott  ret i32 %1
336856d5c58SSam Elliott}
337856d5c58SSam Elliott
338856d5c58SSam Elliott
339856d5c58SSam Elliott; NOTE: This test uses `f8` (`fs0`) as an input, so it should be saved.
340856d5c58SSam Elliottdefine i32 @explicit_register_f8(float %a) nounwind {
341856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f8:
342856d5c58SSam Elliott; RV32IF:       # %bb.0:
343856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
344*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs0, 12(sp) # 4-byte Folded Spill
345856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs0, fa0
346856d5c58SSam Elliott; RV32IF-NEXT:    #APP
347856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs0
348856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
349*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs0, 12(sp) # 4-byte Folded Reload
350856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
351856d5c58SSam Elliott; RV32IF-NEXT:    ret
352856d5c58SSam Elliott;
353856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f8:
354856d5c58SSam Elliott; RV64IF:       # %bb.0:
355856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
356*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs0, 12(sp) # 4-byte Folded Spill
357856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs0, fa0
358856d5c58SSam Elliott; RV64IF-NEXT:    #APP
359856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs0
360856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
361*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs0, 12(sp) # 4-byte Folded Reload
362856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
363856d5c58SSam Elliott; RV64IF-NEXT:    ret
364856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f8}"(float %a)
365856d5c58SSam Elliott  ret i32 %1
366856d5c58SSam Elliott}
367856d5c58SSam Elliott
368856d5c58SSam Elliott; NOTE: This test uses `fs0` (`f8`) as an input, so it should be saved.
369856d5c58SSam Elliottdefine i32 @explicit_register_fs0(float %a) nounwind {
370856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs0:
371856d5c58SSam Elliott; RV32IF:       # %bb.0:
372856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
373*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs0, 12(sp) # 4-byte Folded Spill
374856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs0, fa0
375856d5c58SSam Elliott; RV32IF-NEXT:    #APP
376856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs0
377856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
378*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs0, 12(sp) # 4-byte Folded Reload
379856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
380856d5c58SSam Elliott; RV32IF-NEXT:    ret
381856d5c58SSam Elliott;
382856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs0:
383856d5c58SSam Elliott; RV64IF:       # %bb.0:
384856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
385*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs0, 12(sp) # 4-byte Folded Spill
386856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs0, fa0
387856d5c58SSam Elliott; RV64IF-NEXT:    #APP
388856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs0
389856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
390*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs0, 12(sp) # 4-byte Folded Reload
391856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
392856d5c58SSam Elliott; RV64IF-NEXT:    ret
393856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs0}"(float %a)
394856d5c58SSam Elliott  ret i32 %1
395856d5c58SSam Elliott}
396856d5c58SSam Elliott
397856d5c58SSam Elliott; NOTE: This test uses `f9` (`fs1`) as an input, so it should be saved.
398856d5c58SSam Elliottdefine i32 @explicit_register_f9(float %a) nounwind {
399856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f9:
400856d5c58SSam Elliott; RV32IF:       # %bb.0:
401856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
402*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs1, 12(sp) # 4-byte Folded Spill
403856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs1, fa0
404856d5c58SSam Elliott; RV32IF-NEXT:    #APP
405856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs1
406856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
407*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs1, 12(sp) # 4-byte Folded Reload
408856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
409856d5c58SSam Elliott; RV32IF-NEXT:    ret
410856d5c58SSam Elliott;
411856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f9:
412856d5c58SSam Elliott; RV64IF:       # %bb.0:
413856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
414*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs1, 12(sp) # 4-byte Folded Spill
415856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs1, fa0
416856d5c58SSam Elliott; RV64IF-NEXT:    #APP
417856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs1
418856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
419*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs1, 12(sp) # 4-byte Folded Reload
420856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
421856d5c58SSam Elliott; RV64IF-NEXT:    ret
422856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f9}"(float %a)
423856d5c58SSam Elliott  ret i32 %1
424856d5c58SSam Elliott}
425856d5c58SSam Elliott
426856d5c58SSam Elliott; NOTE: This test uses `fs1` (`f9`) as an input, so it should be saved.
427856d5c58SSam Elliottdefine i32 @explicit_register_fs1(float %a) nounwind {
428856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs1:
429856d5c58SSam Elliott; RV32IF:       # %bb.0:
430856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
431*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs1, 12(sp) # 4-byte Folded Spill
432856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs1, fa0
433856d5c58SSam Elliott; RV32IF-NEXT:    #APP
434856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs1
435856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
436*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs1, 12(sp) # 4-byte Folded Reload
437856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
438856d5c58SSam Elliott; RV32IF-NEXT:    ret
439856d5c58SSam Elliott;
440856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs1:
441856d5c58SSam Elliott; RV64IF:       # %bb.0:
442856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
443*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs1, 12(sp) # 4-byte Folded Spill
444856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs1, fa0
445856d5c58SSam Elliott; RV64IF-NEXT:    #APP
446856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs1
447856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
448*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs1, 12(sp) # 4-byte Folded Reload
449856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
450856d5c58SSam Elliott; RV64IF-NEXT:    ret
451856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs1}"(float %a)
452856d5c58SSam Elliott  ret i32 %1
453856d5c58SSam Elliott}
454856d5c58SSam Elliott
455856d5c58SSam Elliottdefine i32 @explicit_register_f10(float %a) nounwind {
456856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f10:
457856d5c58SSam Elliott; RV32IF:       # %bb.0:
458856d5c58SSam Elliott; RV32IF-NEXT:    #APP
459856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa0
460856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
461856d5c58SSam Elliott; RV32IF-NEXT:    ret
462856d5c58SSam Elliott;
463856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f10:
464856d5c58SSam Elliott; RV64IF:       # %bb.0:
465856d5c58SSam Elliott; RV64IF-NEXT:    #APP
466856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa0
467856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
468856d5c58SSam Elliott; RV64IF-NEXT:    ret
469856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f10}"(float %a)
470856d5c58SSam Elliott  ret i32 %1
471856d5c58SSam Elliott}
472856d5c58SSam Elliott
473856d5c58SSam Elliottdefine i32 @explicit_register_fa0(float %a) nounwind {
474856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fa0:
475856d5c58SSam Elliott; RV32IF:       # %bb.0:
476856d5c58SSam Elliott; RV32IF-NEXT:    #APP
477856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa0
478856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
479856d5c58SSam Elliott; RV32IF-NEXT:    ret
480856d5c58SSam Elliott;
481856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fa0:
482856d5c58SSam Elliott; RV64IF:       # %bb.0:
483856d5c58SSam Elliott; RV64IF-NEXT:    #APP
484856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa0
485856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
486856d5c58SSam Elliott; RV64IF-NEXT:    ret
487856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fa0}"(float %a)
488856d5c58SSam Elliott  ret i32 %1
489856d5c58SSam Elliott}
490856d5c58SSam Elliott
491856d5c58SSam Elliottdefine i32 @explicit_register_f11(float %a) nounwind {
492856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f11:
493856d5c58SSam Elliott; RV32IF:       # %bb.0:
494856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa1, fa0
495856d5c58SSam Elliott; RV32IF-NEXT:    #APP
496856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa1
497856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
498856d5c58SSam Elliott; RV32IF-NEXT:    ret
499856d5c58SSam Elliott;
500856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f11:
501856d5c58SSam Elliott; RV64IF:       # %bb.0:
502856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa1, fa0
503856d5c58SSam Elliott; RV64IF-NEXT:    #APP
504856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa1
505856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
506856d5c58SSam Elliott; RV64IF-NEXT:    ret
507856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f11}"(float %a)
508856d5c58SSam Elliott  ret i32 %1
509856d5c58SSam Elliott}
510856d5c58SSam Elliott
511856d5c58SSam Elliottdefine i32 @explicit_register_fa1(float %a) nounwind {
512856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fa1:
513856d5c58SSam Elliott; RV32IF:       # %bb.0:
514856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa1, fa0
515856d5c58SSam Elliott; RV32IF-NEXT:    #APP
516856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa1
517856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
518856d5c58SSam Elliott; RV32IF-NEXT:    ret
519856d5c58SSam Elliott;
520856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fa1:
521856d5c58SSam Elliott; RV64IF:       # %bb.0:
522856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa1, fa0
523856d5c58SSam Elliott; RV64IF-NEXT:    #APP
524856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa1
525856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
526856d5c58SSam Elliott; RV64IF-NEXT:    ret
527856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fa1}"(float %a)
528856d5c58SSam Elliott  ret i32 %1
529856d5c58SSam Elliott}
530856d5c58SSam Elliott
531856d5c58SSam Elliottdefine i32 @explicit_register_f12(float %a) nounwind {
532856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f12:
533856d5c58SSam Elliott; RV32IF:       # %bb.0:
534856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa2, fa0
535856d5c58SSam Elliott; RV32IF-NEXT:    #APP
536856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa2
537856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
538856d5c58SSam Elliott; RV32IF-NEXT:    ret
539856d5c58SSam Elliott;
540856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f12:
541856d5c58SSam Elliott; RV64IF:       # %bb.0:
542856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa2, fa0
543856d5c58SSam Elliott; RV64IF-NEXT:    #APP
544856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa2
545856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
546856d5c58SSam Elliott; RV64IF-NEXT:    ret
547856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f12}"(float %a)
548856d5c58SSam Elliott  ret i32 %1
549856d5c58SSam Elliott}
550856d5c58SSam Elliott
551856d5c58SSam Elliottdefine i32 @explicit_register_fa2(float %a) nounwind {
552856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fa2:
553856d5c58SSam Elliott; RV32IF:       # %bb.0:
554856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa2, fa0
555856d5c58SSam Elliott; RV32IF-NEXT:    #APP
556856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa2
557856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
558856d5c58SSam Elliott; RV32IF-NEXT:    ret
559856d5c58SSam Elliott;
560856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fa2:
561856d5c58SSam Elliott; RV64IF:       # %bb.0:
562856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa2, fa0
563856d5c58SSam Elliott; RV64IF-NEXT:    #APP
564856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa2
565856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
566856d5c58SSam Elliott; RV64IF-NEXT:    ret
567856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fa2}"(float %a)
568856d5c58SSam Elliott  ret i32 %1
569856d5c58SSam Elliott}
570856d5c58SSam Elliott
571856d5c58SSam Elliottdefine i32 @explicit_register_f13(float %a) nounwind {
572856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f13:
573856d5c58SSam Elliott; RV32IF:       # %bb.0:
574856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa3, fa0
575856d5c58SSam Elliott; RV32IF-NEXT:    #APP
576856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa3
577856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
578856d5c58SSam Elliott; RV32IF-NEXT:    ret
579856d5c58SSam Elliott;
580856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f13:
581856d5c58SSam Elliott; RV64IF:       # %bb.0:
582856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa3, fa0
583856d5c58SSam Elliott; RV64IF-NEXT:    #APP
584856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa3
585856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
586856d5c58SSam Elliott; RV64IF-NEXT:    ret
587856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f13}"(float %a)
588856d5c58SSam Elliott  ret i32 %1
589856d5c58SSam Elliott}
590856d5c58SSam Elliott
591856d5c58SSam Elliottdefine i32 @explicit_register_fa3(float %a) nounwind {
592856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fa3:
593856d5c58SSam Elliott; RV32IF:       # %bb.0:
594856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa3, fa0
595856d5c58SSam Elliott; RV32IF-NEXT:    #APP
596856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa3
597856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
598856d5c58SSam Elliott; RV32IF-NEXT:    ret
599856d5c58SSam Elliott;
600856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fa3:
601856d5c58SSam Elliott; RV64IF:       # %bb.0:
602856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa3, fa0
603856d5c58SSam Elliott; RV64IF-NEXT:    #APP
604856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa3
605856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
606856d5c58SSam Elliott; RV64IF-NEXT:    ret
607856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fa3}"(float %a)
608856d5c58SSam Elliott  ret i32 %1
609856d5c58SSam Elliott}
610856d5c58SSam Elliott
611856d5c58SSam Elliottdefine i32 @explicit_register_f14(float %a) nounwind {
612856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f14:
613856d5c58SSam Elliott; RV32IF:       # %bb.0:
614856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa4, fa0
615856d5c58SSam Elliott; RV32IF-NEXT:    #APP
616856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa4
617856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
618856d5c58SSam Elliott; RV32IF-NEXT:    ret
619856d5c58SSam Elliott;
620856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f14:
621856d5c58SSam Elliott; RV64IF:       # %bb.0:
622856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa4, fa0
623856d5c58SSam Elliott; RV64IF-NEXT:    #APP
624856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa4
625856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
626856d5c58SSam Elliott; RV64IF-NEXT:    ret
627856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f14}"(float %a)
628856d5c58SSam Elliott  ret i32 %1
629856d5c58SSam Elliott}
630856d5c58SSam Elliott
631856d5c58SSam Elliottdefine i32 @explicit_register_fa4(float %a) nounwind {
632856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fa4:
633856d5c58SSam Elliott; RV32IF:       # %bb.0:
634856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa4, fa0
635856d5c58SSam Elliott; RV32IF-NEXT:    #APP
636856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa4
637856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
638856d5c58SSam Elliott; RV32IF-NEXT:    ret
639856d5c58SSam Elliott;
640856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fa4:
641856d5c58SSam Elliott; RV64IF:       # %bb.0:
642856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa4, fa0
643856d5c58SSam Elliott; RV64IF-NEXT:    #APP
644856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa4
645856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
646856d5c58SSam Elliott; RV64IF-NEXT:    ret
647856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fa4}"(float %a)
648856d5c58SSam Elliott  ret i32 %1
649856d5c58SSam Elliott}
650856d5c58SSam Elliott
651856d5c58SSam Elliottdefine i32 @explicit_register_f15(float %a) nounwind {
652856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f15:
653856d5c58SSam Elliott; RV32IF:       # %bb.0:
654856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa5, fa0
655856d5c58SSam Elliott; RV32IF-NEXT:    #APP
656856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa5
657856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
658856d5c58SSam Elliott; RV32IF-NEXT:    ret
659856d5c58SSam Elliott;
660856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f15:
661856d5c58SSam Elliott; RV64IF:       # %bb.0:
662856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa5, fa0
663856d5c58SSam Elliott; RV64IF-NEXT:    #APP
664856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa5
665856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
666856d5c58SSam Elliott; RV64IF-NEXT:    ret
667856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f15}"(float %a)
668856d5c58SSam Elliott  ret i32 %1
669856d5c58SSam Elliott}
670856d5c58SSam Elliott
671856d5c58SSam Elliottdefine i32 @explicit_register_fa5(float %a) nounwind {
672856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fa5:
673856d5c58SSam Elliott; RV32IF:       # %bb.0:
674856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa5, fa0
675856d5c58SSam Elliott; RV32IF-NEXT:    #APP
676856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa5
677856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
678856d5c58SSam Elliott; RV32IF-NEXT:    ret
679856d5c58SSam Elliott;
680856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fa5:
681856d5c58SSam Elliott; RV64IF:       # %bb.0:
682856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa5, fa0
683856d5c58SSam Elliott; RV64IF-NEXT:    #APP
684856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa5
685856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
686856d5c58SSam Elliott; RV64IF-NEXT:    ret
687856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fa5}"(float %a)
688856d5c58SSam Elliott  ret i32 %1
689856d5c58SSam Elliott}
690856d5c58SSam Elliott
691856d5c58SSam Elliottdefine i32 @explicit_register_f16(float %a) nounwind {
692856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f16:
693856d5c58SSam Elliott; RV32IF:       # %bb.0:
694856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa6, fa0
695856d5c58SSam Elliott; RV32IF-NEXT:    #APP
696856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa6
697856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
698856d5c58SSam Elliott; RV32IF-NEXT:    ret
699856d5c58SSam Elliott;
700856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f16:
701856d5c58SSam Elliott; RV64IF:       # %bb.0:
702856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa6, fa0
703856d5c58SSam Elliott; RV64IF-NEXT:    #APP
704856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa6
705856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
706856d5c58SSam Elliott; RV64IF-NEXT:    ret
707856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f16}"(float %a)
708856d5c58SSam Elliott  ret i32 %1
709856d5c58SSam Elliott}
710856d5c58SSam Elliott
711856d5c58SSam Elliottdefine i32 @explicit_register_fa6(float %a) nounwind {
712856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fa6:
713856d5c58SSam Elliott; RV32IF:       # %bb.0:
714856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa6, fa0
715856d5c58SSam Elliott; RV32IF-NEXT:    #APP
716856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa6
717856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
718856d5c58SSam Elliott; RV32IF-NEXT:    ret
719856d5c58SSam Elliott;
720856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fa6:
721856d5c58SSam Elliott; RV64IF:       # %bb.0:
722856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa6, fa0
723856d5c58SSam Elliott; RV64IF-NEXT:    #APP
724856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa6
725856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
726856d5c58SSam Elliott; RV64IF-NEXT:    ret
727856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fa6}"(float %a)
728856d5c58SSam Elliott  ret i32 %1
729856d5c58SSam Elliott}
730856d5c58SSam Elliott
731856d5c58SSam Elliottdefine i32 @explicit_register_f17(float %a) nounwind {
732856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f17:
733856d5c58SSam Elliott; RV32IF:       # %bb.0:
734856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa7, fa0
735856d5c58SSam Elliott; RV32IF-NEXT:    #APP
736856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa7
737856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
738856d5c58SSam Elliott; RV32IF-NEXT:    ret
739856d5c58SSam Elliott;
740856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f17:
741856d5c58SSam Elliott; RV64IF:       # %bb.0:
742856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa7, fa0
743856d5c58SSam Elliott; RV64IF-NEXT:    #APP
744856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa7
745856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
746856d5c58SSam Elliott; RV64IF-NEXT:    ret
747856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f17}"(float %a)
748856d5c58SSam Elliott  ret i32 %1
749856d5c58SSam Elliott}
750856d5c58SSam Elliott
751856d5c58SSam Elliottdefine i32 @explicit_register_fa7(float %a) nounwind {
752856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fa7:
753856d5c58SSam Elliott; RV32IF:       # %bb.0:
754856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fa7, fa0
755856d5c58SSam Elliott; RV32IF-NEXT:    #APP
756856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fa7
757856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
758856d5c58SSam Elliott; RV32IF-NEXT:    ret
759856d5c58SSam Elliott;
760856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fa7:
761856d5c58SSam Elliott; RV64IF:       # %bb.0:
762856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fa7, fa0
763856d5c58SSam Elliott; RV64IF-NEXT:    #APP
764856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fa7
765856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
766856d5c58SSam Elliott; RV64IF-NEXT:    ret
767856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fa7}"(float %a)
768856d5c58SSam Elliott  ret i32 %1
769856d5c58SSam Elliott}
770856d5c58SSam Elliott
771856d5c58SSam Elliott; NOTE: This test uses `f18` (`fs2`) as an input, so it should be saved.
772856d5c58SSam Elliottdefine i32 @explicit_register_f18(float %a) nounwind {
773856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f18:
774856d5c58SSam Elliott; RV32IF:       # %bb.0:
775856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
776*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs2, 12(sp) # 4-byte Folded Spill
777856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs2, fa0
778856d5c58SSam Elliott; RV32IF-NEXT:    #APP
779856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs2
780856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
781*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs2, 12(sp) # 4-byte Folded Reload
782856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
783856d5c58SSam Elliott; RV32IF-NEXT:    ret
784856d5c58SSam Elliott;
785856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f18:
786856d5c58SSam Elliott; RV64IF:       # %bb.0:
787856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
788*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs2, 12(sp) # 4-byte Folded Spill
789856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs2, fa0
790856d5c58SSam Elliott; RV64IF-NEXT:    #APP
791856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs2
792856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
793*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs2, 12(sp) # 4-byte Folded Reload
794856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
795856d5c58SSam Elliott; RV64IF-NEXT:    ret
796856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f18}"(float %a)
797856d5c58SSam Elliott  ret i32 %1
798856d5c58SSam Elliott}
799856d5c58SSam Elliott
800856d5c58SSam Elliott; NOTE: This test uses `fs2` (`f18`) as an input, so it should be saved.
801856d5c58SSam Elliottdefine i32 @explicit_register_fs2(float %a) nounwind {
802856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs2:
803856d5c58SSam Elliott; RV32IF:       # %bb.0:
804856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
805*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs2, 12(sp) # 4-byte Folded Spill
806856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs2, fa0
807856d5c58SSam Elliott; RV32IF-NEXT:    #APP
808856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs2
809856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
810*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs2, 12(sp) # 4-byte Folded Reload
811856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
812856d5c58SSam Elliott; RV32IF-NEXT:    ret
813856d5c58SSam Elliott;
814856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs2:
815856d5c58SSam Elliott; RV64IF:       # %bb.0:
816856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
817*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs2, 12(sp) # 4-byte Folded Spill
818856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs2, fa0
819856d5c58SSam Elliott; RV64IF-NEXT:    #APP
820856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs2
821856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
822*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs2, 12(sp) # 4-byte Folded Reload
823856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
824856d5c58SSam Elliott; RV64IF-NEXT:    ret
825856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs2}"(float %a)
826856d5c58SSam Elliott  ret i32 %1
827856d5c58SSam Elliott}
828856d5c58SSam Elliott
829856d5c58SSam Elliott; NOTE: This test uses `f19` (`fs3`) as an input, so it should be saved.
830856d5c58SSam Elliottdefine i32 @explicit_register_f19(float %a) nounwind {
831856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f19:
832856d5c58SSam Elliott; RV32IF:       # %bb.0:
833856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
834*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs3, 12(sp) # 4-byte Folded Spill
835856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs3, fa0
836856d5c58SSam Elliott; RV32IF-NEXT:    #APP
837856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs3
838856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
839*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs3, 12(sp) # 4-byte Folded Reload
840856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
841856d5c58SSam Elliott; RV32IF-NEXT:    ret
842856d5c58SSam Elliott;
843856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f19:
844856d5c58SSam Elliott; RV64IF:       # %bb.0:
845856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
846*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs3, 12(sp) # 4-byte Folded Spill
847856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs3, fa0
848856d5c58SSam Elliott; RV64IF-NEXT:    #APP
849856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs3
850856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
851*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs3, 12(sp) # 4-byte Folded Reload
852856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
853856d5c58SSam Elliott; RV64IF-NEXT:    ret
854856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f19}"(float %a)
855856d5c58SSam Elliott  ret i32 %1
856856d5c58SSam Elliott}
857856d5c58SSam Elliott
858856d5c58SSam Elliott; NOTE: This test uses `fs3` (`f19`) as an input, so it should be saved.
859856d5c58SSam Elliottdefine i32 @explicit_register_fs3(float %a) nounwind {
860856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs3:
861856d5c58SSam Elliott; RV32IF:       # %bb.0:
862856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
863*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs3, 12(sp) # 4-byte Folded Spill
864856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs3, fa0
865856d5c58SSam Elliott; RV32IF-NEXT:    #APP
866856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs3
867856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
868*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs3, 12(sp) # 4-byte Folded Reload
869856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
870856d5c58SSam Elliott; RV32IF-NEXT:    ret
871856d5c58SSam Elliott;
872856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs3:
873856d5c58SSam Elliott; RV64IF:       # %bb.0:
874856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
875*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs3, 12(sp) # 4-byte Folded Spill
876856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs3, fa0
877856d5c58SSam Elliott; RV64IF-NEXT:    #APP
878856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs3
879856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
880*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs3, 12(sp) # 4-byte Folded Reload
881856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
882856d5c58SSam Elliott; RV64IF-NEXT:    ret
883856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs3}"(float %a)
884856d5c58SSam Elliott  ret i32 %1
885856d5c58SSam Elliott}
886856d5c58SSam Elliott
887856d5c58SSam Elliott; NOTE: This test uses `f20` (`fs4`) as an input, so it should be saved.
888856d5c58SSam Elliottdefine i32 @explicit_register_f20(float %a) nounwind {
889856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f20:
890856d5c58SSam Elliott; RV32IF:       # %bb.0:
891856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
892*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs4, 12(sp) # 4-byte Folded Spill
893856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs4, fa0
894856d5c58SSam Elliott; RV32IF-NEXT:    #APP
895856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs4
896856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
897*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs4, 12(sp) # 4-byte Folded Reload
898856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
899856d5c58SSam Elliott; RV32IF-NEXT:    ret
900856d5c58SSam Elliott;
901856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f20:
902856d5c58SSam Elliott; RV64IF:       # %bb.0:
903856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
904*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs4, 12(sp) # 4-byte Folded Spill
905856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs4, fa0
906856d5c58SSam Elliott; RV64IF-NEXT:    #APP
907856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs4
908856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
909*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs4, 12(sp) # 4-byte Folded Reload
910856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
911856d5c58SSam Elliott; RV64IF-NEXT:    ret
912856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f20}"(float %a)
913856d5c58SSam Elliott  ret i32 %1
914856d5c58SSam Elliott}
915856d5c58SSam Elliott
916856d5c58SSam Elliott; NOTE: This test uses `fs4` (`f20`) as an input, so it should be saved.
917856d5c58SSam Elliottdefine i32 @explicit_register_fs4(float %a) nounwind {
918856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs4:
919856d5c58SSam Elliott; RV32IF:       # %bb.0:
920856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
921*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs4, 12(sp) # 4-byte Folded Spill
922856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs4, fa0
923856d5c58SSam Elliott; RV32IF-NEXT:    #APP
924856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs4
925856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
926*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs4, 12(sp) # 4-byte Folded Reload
927856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
928856d5c58SSam Elliott; RV32IF-NEXT:    ret
929856d5c58SSam Elliott;
930856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs4:
931856d5c58SSam Elliott; RV64IF:       # %bb.0:
932856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
933*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs4, 12(sp) # 4-byte Folded Spill
934856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs4, fa0
935856d5c58SSam Elliott; RV64IF-NEXT:    #APP
936856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs4
937856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
938*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs4, 12(sp) # 4-byte Folded Reload
939856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
940856d5c58SSam Elliott; RV64IF-NEXT:    ret
941856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs4}"(float %a)
942856d5c58SSam Elliott  ret i32 %1
943856d5c58SSam Elliott}
944856d5c58SSam Elliott
945856d5c58SSam Elliott; NOTE: This test uses `f21` (`fs5`) as an input, so it should be saved.
946856d5c58SSam Elliottdefine i32 @explicit_register_f21(float %a) nounwind {
947856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f21:
948856d5c58SSam Elliott; RV32IF:       # %bb.0:
949856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
950*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs5, 12(sp) # 4-byte Folded Spill
951856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs5, fa0
952856d5c58SSam Elliott; RV32IF-NEXT:    #APP
953856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs5
954856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
955*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs5, 12(sp) # 4-byte Folded Reload
956856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
957856d5c58SSam Elliott; RV32IF-NEXT:    ret
958856d5c58SSam Elliott;
959856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f21:
960856d5c58SSam Elliott; RV64IF:       # %bb.0:
961856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
962*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs5, 12(sp) # 4-byte Folded Spill
963856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs5, fa0
964856d5c58SSam Elliott; RV64IF-NEXT:    #APP
965856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs5
966856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
967*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs5, 12(sp) # 4-byte Folded Reload
968856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
969856d5c58SSam Elliott; RV64IF-NEXT:    ret
970856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f21}"(float %a)
971856d5c58SSam Elliott  ret i32 %1
972856d5c58SSam Elliott}
973856d5c58SSam Elliott
974856d5c58SSam Elliott; NOTE: This test uses `fs5` (`f21`) as an input, so it should be saved.
975856d5c58SSam Elliottdefine i32 @explicit_register_fs5(float %a) nounwind {
976856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs5:
977856d5c58SSam Elliott; RV32IF:       # %bb.0:
978856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
979*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs5, 12(sp) # 4-byte Folded Spill
980856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs5, fa0
981856d5c58SSam Elliott; RV32IF-NEXT:    #APP
982856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs5
983856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
984*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs5, 12(sp) # 4-byte Folded Reload
985856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
986856d5c58SSam Elliott; RV32IF-NEXT:    ret
987856d5c58SSam Elliott;
988856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs5:
989856d5c58SSam Elliott; RV64IF:       # %bb.0:
990856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
991*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs5, 12(sp) # 4-byte Folded Spill
992856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs5, fa0
993856d5c58SSam Elliott; RV64IF-NEXT:    #APP
994856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs5
995856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
996*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs5, 12(sp) # 4-byte Folded Reload
997856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
998856d5c58SSam Elliott; RV64IF-NEXT:    ret
999856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs5}"(float %a)
1000856d5c58SSam Elliott  ret i32 %1
1001856d5c58SSam Elliott}
1002856d5c58SSam Elliott
1003856d5c58SSam Elliott; NOTE: This test uses `f22` (`fs6`) as an input, so it should be saved.
1004856d5c58SSam Elliottdefine i32 @explicit_register_f22(float %a) nounwind {
1005856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f22:
1006856d5c58SSam Elliott; RV32IF:       # %bb.0:
1007856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1008*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs6, 12(sp) # 4-byte Folded Spill
1009856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs6, fa0
1010856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1011856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs6
1012856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1013*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs6, 12(sp) # 4-byte Folded Reload
1014856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1015856d5c58SSam Elliott; RV32IF-NEXT:    ret
1016856d5c58SSam Elliott;
1017856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f22:
1018856d5c58SSam Elliott; RV64IF:       # %bb.0:
1019856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1020*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs6, 12(sp) # 4-byte Folded Spill
1021856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs6, fa0
1022856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1023856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs6
1024856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1025*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs6, 12(sp) # 4-byte Folded Reload
1026856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1027856d5c58SSam Elliott; RV64IF-NEXT:    ret
1028856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f22}"(float %a)
1029856d5c58SSam Elliott  ret i32 %1
1030856d5c58SSam Elliott}
1031856d5c58SSam Elliott
1032856d5c58SSam Elliott; NOTE: This test uses `fs6` (`f22`) as an input, so it should be saved.
1033856d5c58SSam Elliottdefine i32 @explicit_register_fs6(float %a) nounwind {
1034856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs6:
1035856d5c58SSam Elliott; RV32IF:       # %bb.0:
1036856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1037*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs6, 12(sp) # 4-byte Folded Spill
1038856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs6, fa0
1039856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1040856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs6
1041856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1042*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs6, 12(sp) # 4-byte Folded Reload
1043856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1044856d5c58SSam Elliott; RV32IF-NEXT:    ret
1045856d5c58SSam Elliott;
1046856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs6:
1047856d5c58SSam Elliott; RV64IF:       # %bb.0:
1048856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1049*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs6, 12(sp) # 4-byte Folded Spill
1050856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs6, fa0
1051856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1052856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs6
1053856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1054*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs6, 12(sp) # 4-byte Folded Reload
1055856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1056856d5c58SSam Elliott; RV64IF-NEXT:    ret
1057856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs6}"(float %a)
1058856d5c58SSam Elliott  ret i32 %1
1059856d5c58SSam Elliott}
1060856d5c58SSam Elliott
1061856d5c58SSam Elliott; NOTE: This test uses `f23` (`fs7`) as an input, so it should be saved.
1062856d5c58SSam Elliottdefine i32 @explicit_register_f23(float %a) nounwind {
1063856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f23:
1064856d5c58SSam Elliott; RV32IF:       # %bb.0:
1065856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1066*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs7, 12(sp) # 4-byte Folded Spill
1067856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs7, fa0
1068856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1069856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs7
1070856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1071*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs7, 12(sp) # 4-byte Folded Reload
1072856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1073856d5c58SSam Elliott; RV32IF-NEXT:    ret
1074856d5c58SSam Elliott;
1075856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f23:
1076856d5c58SSam Elliott; RV64IF:       # %bb.0:
1077856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1078*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs7, 12(sp) # 4-byte Folded Spill
1079856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs7, fa0
1080856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1081856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs7
1082856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1083*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs7, 12(sp) # 4-byte Folded Reload
1084856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1085856d5c58SSam Elliott; RV64IF-NEXT:    ret
1086856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f23}"(float %a)
1087856d5c58SSam Elliott  ret i32 %1
1088856d5c58SSam Elliott}
1089856d5c58SSam Elliott
1090856d5c58SSam Elliott; NOTE: This test uses `fs7` (`f23`) as an input, so it should be saved.
1091856d5c58SSam Elliottdefine i32 @explicit_register_fs7(float %a) nounwind {
1092856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs7:
1093856d5c58SSam Elliott; RV32IF:       # %bb.0:
1094856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1095*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs7, 12(sp) # 4-byte Folded Spill
1096856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs7, fa0
1097856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1098856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs7
1099856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1100*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs7, 12(sp) # 4-byte Folded Reload
1101856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1102856d5c58SSam Elliott; RV32IF-NEXT:    ret
1103856d5c58SSam Elliott;
1104856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs7:
1105856d5c58SSam Elliott; RV64IF:       # %bb.0:
1106856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1107*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs7, 12(sp) # 4-byte Folded Spill
1108856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs7, fa0
1109856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1110856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs7
1111856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1112*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs7, 12(sp) # 4-byte Folded Reload
1113856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1114856d5c58SSam Elliott; RV64IF-NEXT:    ret
1115856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs7}"(float %a)
1116856d5c58SSam Elliott  ret i32 %1
1117856d5c58SSam Elliott}
1118856d5c58SSam Elliott
1119856d5c58SSam Elliott; NOTE: This test uses `f24` (`fs8`) as an input, so it should be saved.
1120856d5c58SSam Elliottdefine i32 @explicit_register_f24(float %a) nounwind {
1121856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f24:
1122856d5c58SSam Elliott; RV32IF:       # %bb.0:
1123856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1124*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs8, 12(sp) # 4-byte Folded Spill
1125856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs8, fa0
1126856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1127856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs8
1128856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1129*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs8, 12(sp) # 4-byte Folded Reload
1130856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1131856d5c58SSam Elliott; RV32IF-NEXT:    ret
1132856d5c58SSam Elliott;
1133856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f24:
1134856d5c58SSam Elliott; RV64IF:       # %bb.0:
1135856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1136*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs8, 12(sp) # 4-byte Folded Spill
1137856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs8, fa0
1138856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1139856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs8
1140856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1141*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs8, 12(sp) # 4-byte Folded Reload
1142856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1143856d5c58SSam Elliott; RV64IF-NEXT:    ret
1144856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f24}"(float %a)
1145856d5c58SSam Elliott  ret i32 %1
1146856d5c58SSam Elliott}
1147856d5c58SSam Elliott
1148856d5c58SSam Elliott; NOTE: This test uses `fs8` (`f24`) as an input, so it should be saved.
1149856d5c58SSam Elliottdefine i32 @explicit_register_fs8(float %a) nounwind {
1150856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs8:
1151856d5c58SSam Elliott; RV32IF:       # %bb.0:
1152856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1153*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs8, 12(sp) # 4-byte Folded Spill
1154856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs8, fa0
1155856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1156856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs8
1157856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1158*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs8, 12(sp) # 4-byte Folded Reload
1159856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1160856d5c58SSam Elliott; RV32IF-NEXT:    ret
1161856d5c58SSam Elliott;
1162856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs8:
1163856d5c58SSam Elliott; RV64IF:       # %bb.0:
1164856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1165*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs8, 12(sp) # 4-byte Folded Spill
1166856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs8, fa0
1167856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1168856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs8
1169856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1170*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs8, 12(sp) # 4-byte Folded Reload
1171856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1172856d5c58SSam Elliott; RV64IF-NEXT:    ret
1173856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs8}"(float %a)
1174856d5c58SSam Elliott  ret i32 %1
1175856d5c58SSam Elliott}
1176856d5c58SSam Elliott
1177856d5c58SSam Elliott; NOTE: This test uses `f25` (`fs9`) as an input, so it should be saved.
1178856d5c58SSam Elliottdefine i32 @explicit_register_f25(float %a) nounwind {
1179856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f25:
1180856d5c58SSam Elliott; RV32IF:       # %bb.0:
1181856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1182*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs9, 12(sp) # 4-byte Folded Spill
1183856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs9, fa0
1184856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1185856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs9
1186856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1187*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs9, 12(sp) # 4-byte Folded Reload
1188856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1189856d5c58SSam Elliott; RV32IF-NEXT:    ret
1190856d5c58SSam Elliott;
1191856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f25:
1192856d5c58SSam Elliott; RV64IF:       # %bb.0:
1193856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1194*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs9, 12(sp) # 4-byte Folded Spill
1195856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs9, fa0
1196856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1197856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs9
1198856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1199*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs9, 12(sp) # 4-byte Folded Reload
1200856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1201856d5c58SSam Elliott; RV64IF-NEXT:    ret
1202856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f25}"(float %a)
1203856d5c58SSam Elliott  ret i32 %1
1204856d5c58SSam Elliott}
1205856d5c58SSam Elliott
1206856d5c58SSam Elliott; NOTE: This test uses `fs9` (`f25`) as an input, so it should be saved.
1207856d5c58SSam Elliottdefine i32 @explicit_register_fs9(float %a) nounwind {
1208856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs9:
1209856d5c58SSam Elliott; RV32IF:       # %bb.0:
1210856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1211*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs9, 12(sp) # 4-byte Folded Spill
1212856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs9, fa0
1213856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1214856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs9
1215856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1216*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs9, 12(sp) # 4-byte Folded Reload
1217856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1218856d5c58SSam Elliott; RV32IF-NEXT:    ret
1219856d5c58SSam Elliott;
1220856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs9:
1221856d5c58SSam Elliott; RV64IF:       # %bb.0:
1222856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1223*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs9, 12(sp) # 4-byte Folded Spill
1224856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs9, fa0
1225856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1226856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs9
1227856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1228*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs9, 12(sp) # 4-byte Folded Reload
1229856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1230856d5c58SSam Elliott; RV64IF-NEXT:    ret
1231856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs9}"(float %a)
1232856d5c58SSam Elliott  ret i32 %1
1233856d5c58SSam Elliott}
1234856d5c58SSam Elliott
1235856d5c58SSam Elliott; NOTE: This test uses `f26` (`fs10`) as an input, so it should be saved.
1236856d5c58SSam Elliottdefine i32 @explicit_register_f26(float %a) nounwind {
1237856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f26:
1238856d5c58SSam Elliott; RV32IF:       # %bb.0:
1239856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1240*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs10, 12(sp) # 4-byte Folded Spill
1241856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs10, fa0
1242856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1243856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs10
1244856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1245*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs10, 12(sp) # 4-byte Folded Reload
1246856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1247856d5c58SSam Elliott; RV32IF-NEXT:    ret
1248856d5c58SSam Elliott;
1249856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f26:
1250856d5c58SSam Elliott; RV64IF:       # %bb.0:
1251856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1252*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs10, 12(sp) # 4-byte Folded Spill
1253856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs10, fa0
1254856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1255856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs10
1256856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1257*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs10, 12(sp) # 4-byte Folded Reload
1258856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1259856d5c58SSam Elliott; RV64IF-NEXT:    ret
1260856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f26}"(float %a)
1261856d5c58SSam Elliott  ret i32 %1
1262856d5c58SSam Elliott}
1263856d5c58SSam Elliott
1264856d5c58SSam Elliott; NOTE: This test uses `fs10` (`f26`) as an input, so it should be saved.
1265856d5c58SSam Elliottdefine i32 @explicit_register_fs10(float %a) nounwind {
1266856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs10:
1267856d5c58SSam Elliott; RV32IF:       # %bb.0:
1268856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1269*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs10, 12(sp) # 4-byte Folded Spill
1270856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs10, fa0
1271856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1272856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs10
1273856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1274*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs10, 12(sp) # 4-byte Folded Reload
1275856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1276856d5c58SSam Elliott; RV32IF-NEXT:    ret
1277856d5c58SSam Elliott;
1278856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs10:
1279856d5c58SSam Elliott; RV64IF:       # %bb.0:
1280856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1281*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs10, 12(sp) # 4-byte Folded Spill
1282856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs10, fa0
1283856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1284856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs10
1285856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1286*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs10, 12(sp) # 4-byte Folded Reload
1287856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1288856d5c58SSam Elliott; RV64IF-NEXT:    ret
1289856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs10}"(float %a)
1290856d5c58SSam Elliott  ret i32 %1
1291856d5c58SSam Elliott}
1292856d5c58SSam Elliott
1293856d5c58SSam Elliott; NOTE: This test uses `f27` (`fs11`) as an input, so it should be saved.
1294856d5c58SSam Elliottdefine i32 @explicit_register_f27(float %a) nounwind {
1295856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f27:
1296856d5c58SSam Elliott; RV32IF:       # %bb.0:
1297856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1298*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs11, 12(sp) # 4-byte Folded Spill
1299856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs11, fa0
1300856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1301856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs11
1302856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1303*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs11, 12(sp) # 4-byte Folded Reload
1304856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1305856d5c58SSam Elliott; RV32IF-NEXT:    ret
1306856d5c58SSam Elliott;
1307856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f27:
1308856d5c58SSam Elliott; RV64IF:       # %bb.0:
1309856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1310*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs11, 12(sp) # 4-byte Folded Spill
1311856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs11, fa0
1312856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1313856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs11
1314856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1315*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs11, 12(sp) # 4-byte Folded Reload
1316856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1317856d5c58SSam Elliott; RV64IF-NEXT:    ret
1318856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f27}"(float %a)
1319856d5c58SSam Elliott  ret i32 %1
1320856d5c58SSam Elliott}
1321856d5c58SSam Elliott
1322856d5c58SSam Elliott; NOTE: This test uses `fs11` (`f27`) as an input, so it should be saved.
1323856d5c58SSam Elliottdefine i32 @explicit_register_fs11(float %a) nounwind {
1324856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_fs11:
1325856d5c58SSam Elliott; RV32IF:       # %bb.0:
1326856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, -16
1327*e28b6a60SMichael Munday; RV32IF-NEXT:    fsw fs11, 12(sp) # 4-byte Folded Spill
1328856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s fs11, fa0
1329856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1330856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, fs11
1331856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1332*e28b6a60SMichael Munday; RV32IF-NEXT:    flw fs11, 12(sp) # 4-byte Folded Reload
1333856d5c58SSam Elliott; RV32IF-NEXT:    addi sp, sp, 16
1334856d5c58SSam Elliott; RV32IF-NEXT:    ret
1335856d5c58SSam Elliott;
1336856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_fs11:
1337856d5c58SSam Elliott; RV64IF:       # %bb.0:
1338856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, -16
1339*e28b6a60SMichael Munday; RV64IF-NEXT:    fsw fs11, 12(sp) # 4-byte Folded Spill
1340856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s fs11, fa0
1341856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1342856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, fs11
1343856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1344*e28b6a60SMichael Munday; RV64IF-NEXT:    flw fs11, 12(sp) # 4-byte Folded Reload
1345856d5c58SSam Elliott; RV64IF-NEXT:    addi sp, sp, 16
1346856d5c58SSam Elliott; RV64IF-NEXT:    ret
1347856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{fs11}"(float %a)
1348856d5c58SSam Elliott  ret i32 %1
1349856d5c58SSam Elliott}
1350856d5c58SSam Elliott
1351856d5c58SSam Elliottdefine i32 @explicit_register_f28(float %a) nounwind {
1352856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f28:
1353856d5c58SSam Elliott; RV32IF:       # %bb.0:
1354856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft8, fa0
1355856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1356856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft8
1357856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1358856d5c58SSam Elliott; RV32IF-NEXT:    ret
1359856d5c58SSam Elliott;
1360856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f28:
1361856d5c58SSam Elliott; RV64IF:       # %bb.0:
1362856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft8, fa0
1363856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1364856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft8
1365856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1366856d5c58SSam Elliott; RV64IF-NEXT:    ret
1367856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f28}"(float %a)
1368856d5c58SSam Elliott  ret i32 %1
1369856d5c58SSam Elliott}
1370856d5c58SSam Elliott
1371856d5c58SSam Elliottdefine i32 @explicit_register_ft8(float %a) nounwind {
1372856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft8:
1373856d5c58SSam Elliott; RV32IF:       # %bb.0:
1374856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft8, fa0
1375856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1376856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft8
1377856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1378856d5c58SSam Elliott; RV32IF-NEXT:    ret
1379856d5c58SSam Elliott;
1380856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft8:
1381856d5c58SSam Elliott; RV64IF:       # %bb.0:
1382856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft8, fa0
1383856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1384856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft8
1385856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1386856d5c58SSam Elliott; RV64IF-NEXT:    ret
1387856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft8}"(float %a)
1388856d5c58SSam Elliott  ret i32 %1
1389856d5c58SSam Elliott}
1390856d5c58SSam Elliott
1391856d5c58SSam Elliottdefine i32 @explicit_register_f29(float %a) nounwind {
1392856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f29:
1393856d5c58SSam Elliott; RV32IF:       # %bb.0:
1394856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft9, fa0
1395856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1396856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft9
1397856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1398856d5c58SSam Elliott; RV32IF-NEXT:    ret
1399856d5c58SSam Elliott;
1400856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f29:
1401856d5c58SSam Elliott; RV64IF:       # %bb.0:
1402856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft9, fa0
1403856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1404856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft9
1405856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1406856d5c58SSam Elliott; RV64IF-NEXT:    ret
1407856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f29}"(float %a)
1408856d5c58SSam Elliott  ret i32 %1
1409856d5c58SSam Elliott}
1410856d5c58SSam Elliott
1411856d5c58SSam Elliottdefine i32 @explicit_register_ft9(float %a) nounwind {
1412856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft9:
1413856d5c58SSam Elliott; RV32IF:       # %bb.0:
1414856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft9, fa0
1415856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1416856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft9
1417856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1418856d5c58SSam Elliott; RV32IF-NEXT:    ret
1419856d5c58SSam Elliott;
1420856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft9:
1421856d5c58SSam Elliott; RV64IF:       # %bb.0:
1422856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft9, fa0
1423856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1424856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft9
1425856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1426856d5c58SSam Elliott; RV64IF-NEXT:    ret
1427856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft9}"(float %a)
1428856d5c58SSam Elliott  ret i32 %1
1429856d5c58SSam Elliott}
1430856d5c58SSam Elliott
1431856d5c58SSam Elliottdefine i32 @explicit_register_f30(float %a) nounwind {
1432856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f30:
1433856d5c58SSam Elliott; RV32IF:       # %bb.0:
1434856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft10, fa0
1435856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1436856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft10
1437856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1438856d5c58SSam Elliott; RV32IF-NEXT:    ret
1439856d5c58SSam Elliott;
1440856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f30:
1441856d5c58SSam Elliott; RV64IF:       # %bb.0:
1442856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft10, fa0
1443856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1444856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft10
1445856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1446856d5c58SSam Elliott; RV64IF-NEXT:    ret
1447856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f30}"(float %a)
1448856d5c58SSam Elliott  ret i32 %1
1449856d5c58SSam Elliott}
1450856d5c58SSam Elliott
1451856d5c58SSam Elliottdefine i32 @explicit_register_ft10(float %a) nounwind {
1452856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft10:
1453856d5c58SSam Elliott; RV32IF:       # %bb.0:
1454856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft10, fa0
1455856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1456856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft10
1457856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1458856d5c58SSam Elliott; RV32IF-NEXT:    ret
1459856d5c58SSam Elliott;
1460856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft10:
1461856d5c58SSam Elliott; RV64IF:       # %bb.0:
1462856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft10, fa0
1463856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1464856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft10
1465856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1466856d5c58SSam Elliott; RV64IF-NEXT:    ret
1467856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft10}"(float %a)
1468856d5c58SSam Elliott  ret i32 %1
1469856d5c58SSam Elliott}
1470856d5c58SSam Elliott
1471856d5c58SSam Elliottdefine i32 @explicit_register_f31(float %a) nounwind {
1472856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_f31:
1473856d5c58SSam Elliott; RV32IF:       # %bb.0:
1474856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft11, fa0
1475856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1476856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft11
1477856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1478856d5c58SSam Elliott; RV32IF-NEXT:    ret
1479856d5c58SSam Elliott;
1480856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_f31:
1481856d5c58SSam Elliott; RV64IF:       # %bb.0:
1482856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft11, fa0
1483856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1484856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft11
1485856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1486856d5c58SSam Elliott; RV64IF-NEXT:    ret
1487856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{f31}"(float %a)
1488856d5c58SSam Elliott  ret i32 %1
1489856d5c58SSam Elliott}
1490856d5c58SSam Elliott
1491856d5c58SSam Elliottdefine i32 @explicit_register_ft11(float %a) nounwind {
1492856d5c58SSam Elliott; RV32IF-LABEL: explicit_register_ft11:
1493856d5c58SSam Elliott; RV32IF:       # %bb.0:
1494856d5c58SSam Elliott; RV32IF-NEXT:    fmv.s ft11, fa0
1495856d5c58SSam Elliott; RV32IF-NEXT:    #APP
1496856d5c58SSam Elliott; RV32IF-NEXT:    fcvt.w.s a0, ft11
1497856d5c58SSam Elliott; RV32IF-NEXT:    #NO_APP
1498856d5c58SSam Elliott; RV32IF-NEXT:    ret
1499856d5c58SSam Elliott;
1500856d5c58SSam Elliott; RV64IF-LABEL: explicit_register_ft11:
1501856d5c58SSam Elliott; RV64IF:       # %bb.0:
1502856d5c58SSam Elliott; RV64IF-NEXT:    fmv.s ft11, fa0
1503856d5c58SSam Elliott; RV64IF-NEXT:    #APP
1504856d5c58SSam Elliott; RV64IF-NEXT:    fcvt.w.s a0, ft11
1505856d5c58SSam Elliott; RV64IF-NEXT:    #NO_APP
1506856d5c58SSam Elliott; RV64IF-NEXT:    ret
1507856d5c58SSam Elliott  %1 = tail call i32 asm "fcvt.w.s $0, $1", "=r,{ft11}"(float %a)
1508856d5c58SSam Elliott  ret i32 %1
1509856d5c58SSam Elliott}
1510