xref: /llvm-project/llvm/test/CodeGen/AArch64/fexplog.ll (revision 61510b51c33464a6bc15e4cf5b1ee07e2e0ec1c9) 
1; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py UTC_ARGS: --version 3
2; RUN: llc -mtriple=aarch64 -verify-machineinstrs %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-SD
3; RUN: llc -mtriple=aarch64 -global-isel -verify-machineinstrs %s -o - | FileCheck %s --check-prefixes=CHECK,CHECK-GI
4
5define double @exp_f64(double %a) {
6; CHECK-LABEL: exp_f64:
7; CHECK:       // %bb.0: // %entry
8; CHECK-NEXT:    b exp
9entry:
10  %c = call double @llvm.exp.f64(double %a)
11  ret double %c
12}
13
14define float @exp_f32(float %a) {
15; CHECK-LABEL: exp_f32:
16; CHECK:       // %bb.0: // %entry
17; CHECK-NEXT:    b expf
18entry:
19  %c = call float @llvm.exp.f32(float %a)
20  ret float %c
21}
22
23define half @exp_f16(half %a) {
24; CHECK-LABEL: exp_f16:
25; CHECK:       // %bb.0: // %entry
26; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
27; CHECK-NEXT:    .cfi_def_cfa_offset 16
28; CHECK-NEXT:    .cfi_offset w30, -16
29; CHECK-NEXT:    fcvt s0, h0
30; CHECK-NEXT:    bl expf
31; CHECK-NEXT:    fcvt h0, s0
32; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
33; CHECK-NEXT:    ret
34entry:
35  %c = call half @llvm.exp.f16(half %a)
36  ret half %c
37}
38
39define fp128 @exp_fp128(fp128 %a) {
40; CHECK-LABEL: exp_fp128:
41; CHECK:       // %bb.0: // %entry
42; CHECK-NEXT:    b expl
43entry:
44  %c = call fp128 @llvm.exp.fp128(fp128 %a)
45  ret fp128 %c
46}
47
48define <1 x double> @exp_v1f64(<1 x double> %a) {
49; CHECK-LABEL: exp_v1f64:
50; CHECK:       // %bb.0: // %entry
51; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
52; CHECK-NEXT:    .cfi_def_cfa_offset 16
53; CHECK-NEXT:    .cfi_offset w30, -16
54; CHECK-NEXT:    bl exp
55; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
56; CHECK-NEXT:    ret
57entry:
58  %c = call <1 x double> @llvm.exp.v1f64(<1 x double> %a)
59  ret <1 x double> %c
60}
61
62define <2 x double> @exp_v2f64(<2 x double> %a) {
63; CHECK-SD-LABEL: exp_v2f64:
64; CHECK-SD:       // %bb.0: // %entry
65; CHECK-SD-NEXT:    sub sp, sp, #48
66; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
67; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
68; CHECK-SD-NEXT:    .cfi_offset w30, -16
69; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
70; CHECK-SD-NEXT:    mov d0, v0.d[1]
71; CHECK-SD-NEXT:    bl exp
72; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
73; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
74; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
75; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
76; CHECK-SD-NEXT:    bl exp
77; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
78; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
79; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
80; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
81; CHECK-SD-NEXT:    add sp, sp, #48
82; CHECK-SD-NEXT:    ret
83;
84; CHECK-GI-LABEL: exp_v2f64:
85; CHECK-GI:       // %bb.0: // %entry
86; CHECK-GI-NEXT:    sub sp, sp, #32
87; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
88; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
89; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
90; CHECK-GI-NEXT:    .cfi_offset w30, -8
91; CHECK-GI-NEXT:    .cfi_offset b8, -16
92; CHECK-GI-NEXT:    mov d8, v0.d[1]
93; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
94; CHECK-GI-NEXT:    bl exp
95; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
96; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
97; CHECK-GI-NEXT:    fmov d0, d8
98; CHECK-GI-NEXT:    bl exp
99; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
100; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
101; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
102; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
103; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
104; CHECK-GI-NEXT:    mov v0.16b, v1.16b
105; CHECK-GI-NEXT:    add sp, sp, #32
106; CHECK-GI-NEXT:    ret
107entry:
108  %c = call <2 x double> @llvm.exp.v2f64(<2 x double> %a)
109  ret <2 x double> %c
110}
111
112define <3 x double> @exp_v3f64(<3 x double> %a) {
113; CHECK-SD-LABEL: exp_v3f64:
114; CHECK-SD:       // %bb.0: // %entry
115; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
116; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
117; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
118; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
119; CHECK-SD-NEXT:    .cfi_offset w30, -8
120; CHECK-SD-NEXT:    .cfi_offset b8, -16
121; CHECK-SD-NEXT:    .cfi_offset b9, -24
122; CHECK-SD-NEXT:    .cfi_offset b10, -32
123; CHECK-SD-NEXT:    fmov d8, d2
124; CHECK-SD-NEXT:    fmov d9, d1
125; CHECK-SD-NEXT:    bl exp
126; CHECK-SD-NEXT:    fmov d10, d0
127; CHECK-SD-NEXT:    fmov d0, d9
128; CHECK-SD-NEXT:    bl exp
129; CHECK-SD-NEXT:    fmov d9, d0
130; CHECK-SD-NEXT:    fmov d0, d8
131; CHECK-SD-NEXT:    bl exp
132; CHECK-SD-NEXT:    fmov d1, d9
133; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
134; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
135; CHECK-SD-NEXT:    fmov d2, d0
136; CHECK-SD-NEXT:    fmov d0, d10
137; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
138; CHECK-SD-NEXT:    ret
139;
140; CHECK-GI-LABEL: exp_v3f64:
141; CHECK-GI:       // %bb.0: // %entry
142; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
143; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
144; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
145; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
146; CHECK-GI-NEXT:    .cfi_offset w30, -8
147; CHECK-GI-NEXT:    .cfi_offset b8, -16
148; CHECK-GI-NEXT:    .cfi_offset b9, -24
149; CHECK-GI-NEXT:    .cfi_offset b10, -32
150; CHECK-GI-NEXT:    fmov d8, d1
151; CHECK-GI-NEXT:    fmov d9, d2
152; CHECK-GI-NEXT:    bl exp
153; CHECK-GI-NEXT:    fmov d10, d0
154; CHECK-GI-NEXT:    fmov d0, d8
155; CHECK-GI-NEXT:    bl exp
156; CHECK-GI-NEXT:    fmov d8, d0
157; CHECK-GI-NEXT:    fmov d0, d9
158; CHECK-GI-NEXT:    bl exp
159; CHECK-GI-NEXT:    fmov d1, d8
160; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
161; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
162; CHECK-GI-NEXT:    fmov d2, d0
163; CHECK-GI-NEXT:    fmov d0, d10
164; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
165; CHECK-GI-NEXT:    ret
166entry:
167  %c = call <3 x double> @llvm.exp.v3f64(<3 x double> %a)
168  ret <3 x double> %c
169}
170
171define <4 x double> @exp_v4f64(<4 x double> %a) {
172; CHECK-SD-LABEL: exp_v4f64:
173; CHECK-SD:       // %bb.0: // %entry
174; CHECK-SD-NEXT:    sub sp, sp, #64
175; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
176; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
177; CHECK-SD-NEXT:    .cfi_offset w30, -16
178; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
179; CHECK-SD-NEXT:    mov d0, v0.d[1]
180; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
181; CHECK-SD-NEXT:    bl exp
182; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
183; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
184; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
185; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
186; CHECK-SD-NEXT:    bl exp
187; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
188; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
189; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
190; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
191; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
192; CHECK-SD-NEXT:    mov d0, v0.d[1]
193; CHECK-SD-NEXT:    bl exp
194; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
195; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
196; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
197; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
198; CHECK-SD-NEXT:    bl exp
199; CHECK-SD-NEXT:    fmov d1, d0
200; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
201; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
202; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
203; CHECK-SD-NEXT:    add sp, sp, #64
204; CHECK-SD-NEXT:    ret
205;
206; CHECK-GI-LABEL: exp_v4f64:
207; CHECK-GI:       // %bb.0: // %entry
208; CHECK-GI-NEXT:    sub sp, sp, #80
209; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
210; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
211; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
212; CHECK-GI-NEXT:    .cfi_offset w30, -16
213; CHECK-GI-NEXT:    .cfi_offset b8, -24
214; CHECK-GI-NEXT:    .cfi_offset b9, -32
215; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
216; CHECK-GI-NEXT:    mov d8, v0.d[1]
217; CHECK-GI-NEXT:    mov d9, v1.d[1]
218; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
219; CHECK-GI-NEXT:    bl exp
220; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
221; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
222; CHECK-GI-NEXT:    fmov d0, d8
223; CHECK-GI-NEXT:    bl exp
224; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
225; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
226; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
227; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
228; CHECK-GI-NEXT:    bl exp
229; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
230; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
231; CHECK-GI-NEXT:    fmov d0, d9
232; CHECK-GI-NEXT:    bl exp
233; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
234; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
235; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
236; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
237; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
238; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
239; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
240; CHECK-GI-NEXT:    mov v0.16b, v2.16b
241; CHECK-GI-NEXT:    add sp, sp, #80
242; CHECK-GI-NEXT:    ret
243entry:
244  %c = call <4 x double> @llvm.exp.v4f64(<4 x double> %a)
245  ret <4 x double> %c
246}
247
248define <2 x float> @exp_v2f32(<2 x float> %a) {
249; CHECK-SD-LABEL: exp_v2f32:
250; CHECK-SD:       // %bb.0: // %entry
251; CHECK-SD-NEXT:    sub sp, sp, #48
252; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
253; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
254; CHECK-SD-NEXT:    .cfi_offset w30, -16
255; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
256; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
257; CHECK-SD-NEXT:    mov s0, v0.s[1]
258; CHECK-SD-NEXT:    bl expf
259; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
260; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
261; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
262; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
263; CHECK-SD-NEXT:    bl expf
264; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
265; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
266; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
267; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
268; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
269; CHECK-SD-NEXT:    add sp, sp, #48
270; CHECK-SD-NEXT:    ret
271;
272; CHECK-GI-LABEL: exp_v2f32:
273; CHECK-GI:       // %bb.0: // %entry
274; CHECK-GI-NEXT:    sub sp, sp, #32
275; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
276; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
277; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
278; CHECK-GI-NEXT:    .cfi_offset w30, -8
279; CHECK-GI-NEXT:    .cfi_offset b8, -16
280; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
281; CHECK-GI-NEXT:    mov s8, v0.s[1]
282; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
283; CHECK-GI-NEXT:    bl expf
284; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
285; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
286; CHECK-GI-NEXT:    fmov s0, s8
287; CHECK-GI-NEXT:    bl expf
288; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
289; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
290; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
291; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
292; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
293; CHECK-GI-NEXT:    fmov d0, d1
294; CHECK-GI-NEXT:    add sp, sp, #32
295; CHECK-GI-NEXT:    ret
296entry:
297  %c = call <2 x float> @llvm.exp.v2f32(<2 x float> %a)
298  ret <2 x float> %c
299}
300
301define <3 x float> @exp_v3f32(<3 x float> %a) {
302; CHECK-SD-LABEL: exp_v3f32:
303; CHECK-SD:       // %bb.0: // %entry
304; CHECK-SD-NEXT:    sub sp, sp, #48
305; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
306; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
307; CHECK-SD-NEXT:    .cfi_offset w30, -16
308; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
309; CHECK-SD-NEXT:    mov s0, v0.s[1]
310; CHECK-SD-NEXT:    bl expf
311; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
312; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
313; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
314; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
315; CHECK-SD-NEXT:    bl expf
316; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
317; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
318; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
319; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
320; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
321; CHECK-SD-NEXT:    mov s0, v0.s[2]
322; CHECK-SD-NEXT:    bl expf
323; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
324; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
325; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
326; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
327; CHECK-SD-NEXT:    mov v0.16b, v1.16b
328; CHECK-SD-NEXT:    add sp, sp, #48
329; CHECK-SD-NEXT:    ret
330;
331; CHECK-GI-LABEL: exp_v3f32:
332; CHECK-GI:       // %bb.0: // %entry
333; CHECK-GI-NEXT:    sub sp, sp, #64
334; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
335; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
336; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
337; CHECK-GI-NEXT:    .cfi_offset w30, -16
338; CHECK-GI-NEXT:    .cfi_offset b8, -24
339; CHECK-GI-NEXT:    .cfi_offset b9, -32
340; CHECK-GI-NEXT:    mov s8, v0.s[1]
341; CHECK-GI-NEXT:    mov s9, v0.s[2]
342; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
343; CHECK-GI-NEXT:    bl expf
344; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
345; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
346; CHECK-GI-NEXT:    fmov s0, s8
347; CHECK-GI-NEXT:    bl expf
348; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
349; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
350; CHECK-GI-NEXT:    fmov s0, s9
351; CHECK-GI-NEXT:    bl expf
352; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
353; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
354; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
355; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
356; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
357; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
358; CHECK-GI-NEXT:    mov v0.16b, v1.16b
359; CHECK-GI-NEXT:    add sp, sp, #64
360; CHECK-GI-NEXT:    ret
361entry:
362  %c = call <3 x float> @llvm.exp.v3f32(<3 x float> %a)
363  ret <3 x float> %c
364}
365
366define <4 x float> @exp_v4f32(<4 x float> %a) {
367; CHECK-SD-LABEL: exp_v4f32:
368; CHECK-SD:       // %bb.0: // %entry
369; CHECK-SD-NEXT:    sub sp, sp, #48
370; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
371; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
372; CHECK-SD-NEXT:    .cfi_offset w30, -16
373; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
374; CHECK-SD-NEXT:    mov s0, v0.s[1]
375; CHECK-SD-NEXT:    bl expf
376; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
377; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
378; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
379; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
380; CHECK-SD-NEXT:    bl expf
381; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
382; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
383; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
384; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
385; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
386; CHECK-SD-NEXT:    mov s0, v0.s[2]
387; CHECK-SD-NEXT:    bl expf
388; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
389; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
390; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
391; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
392; CHECK-SD-NEXT:    mov s0, v0.s[3]
393; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
394; CHECK-SD-NEXT:    bl expf
395; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
396; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
397; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
398; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
399; CHECK-SD-NEXT:    mov v0.16b, v1.16b
400; CHECK-SD-NEXT:    add sp, sp, #48
401; CHECK-SD-NEXT:    ret
402;
403; CHECK-GI-LABEL: exp_v4f32:
404; CHECK-GI:       // %bb.0: // %entry
405; CHECK-GI-NEXT:    sub sp, sp, #80
406; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
407; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
408; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
409; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
410; CHECK-GI-NEXT:    .cfi_offset w30, -8
411; CHECK-GI-NEXT:    .cfi_offset b8, -16
412; CHECK-GI-NEXT:    .cfi_offset b9, -24
413; CHECK-GI-NEXT:    .cfi_offset b10, -32
414; CHECK-GI-NEXT:    mov s8, v0.s[1]
415; CHECK-GI-NEXT:    mov s9, v0.s[2]
416; CHECK-GI-NEXT:    mov s10, v0.s[3]
417; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
418; CHECK-GI-NEXT:    bl expf
419; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
420; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
421; CHECK-GI-NEXT:    fmov s0, s8
422; CHECK-GI-NEXT:    bl expf
423; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
424; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
425; CHECK-GI-NEXT:    fmov s0, s9
426; CHECK-GI-NEXT:    bl expf
427; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
428; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
429; CHECK-GI-NEXT:    fmov s0, s10
430; CHECK-GI-NEXT:    bl expf
431; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
432; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
433; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
434; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
435; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
436; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
437; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
438; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
439; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
440; CHECK-GI-NEXT:    mov v0.16b, v1.16b
441; CHECK-GI-NEXT:    add sp, sp, #80
442; CHECK-GI-NEXT:    ret
443entry:
444  %c = call <4 x float> @llvm.exp.v4f32(<4 x float> %a)
445  ret <4 x float> %c
446}
447
448define <8 x float> @exp_v8f32(<8 x float> %a) {
449; CHECK-SD-LABEL: exp_v8f32:
450; CHECK-SD:       // %bb.0: // %entry
451; CHECK-SD-NEXT:    sub sp, sp, #64
452; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
453; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
454; CHECK-SD-NEXT:    .cfi_offset w30, -16
455; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
456; CHECK-SD-NEXT:    mov s0, v0.s[1]
457; CHECK-SD-NEXT:    bl expf
458; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
459; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
460; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
461; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
462; CHECK-SD-NEXT:    bl expf
463; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
464; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
465; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
466; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
467; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
468; CHECK-SD-NEXT:    mov s0, v0.s[2]
469; CHECK-SD-NEXT:    bl expf
470; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
471; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
472; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
473; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
474; CHECK-SD-NEXT:    mov s0, v0.s[3]
475; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
476; CHECK-SD-NEXT:    bl expf
477; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
478; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
479; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
480; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
481; CHECK-SD-NEXT:    mov s0, v0.s[1]
482; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
483; CHECK-SD-NEXT:    bl expf
484; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
485; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
486; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
487; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
488; CHECK-SD-NEXT:    bl expf
489; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
490; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
491; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
492; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
493; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
494; CHECK-SD-NEXT:    mov s0, v0.s[2]
495; CHECK-SD-NEXT:    bl expf
496; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
497; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
498; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
499; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
500; CHECK-SD-NEXT:    mov s0, v0.s[3]
501; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
502; CHECK-SD-NEXT:    bl expf
503; CHECK-SD-NEXT:    fmov s2, s0
504; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
505; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
506; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
507; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
508; CHECK-SD-NEXT:    add sp, sp, #64
509; CHECK-SD-NEXT:    ret
510;
511; CHECK-GI-LABEL: exp_v8f32:
512; CHECK-GI:       // %bb.0: // %entry
513; CHECK-GI-NEXT:    sub sp, sp, #176
514; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
515; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
516; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
517; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
518; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
519; CHECK-GI-NEXT:    .cfi_offset w30, -16
520; CHECK-GI-NEXT:    .cfi_offset b8, -24
521; CHECK-GI-NEXT:    .cfi_offset b9, -32
522; CHECK-GI-NEXT:    .cfi_offset b10, -40
523; CHECK-GI-NEXT:    .cfi_offset b11, -48
524; CHECK-GI-NEXT:    .cfi_offset b12, -56
525; CHECK-GI-NEXT:    .cfi_offset b13, -64
526; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
527; CHECK-GI-NEXT:    mov s8, v0.s[1]
528; CHECK-GI-NEXT:    mov s9, v0.s[2]
529; CHECK-GI-NEXT:    mov s10, v0.s[3]
530; CHECK-GI-NEXT:    mov s11, v1.s[1]
531; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
532; CHECK-GI-NEXT:    mov s12, v1.s[2]
533; CHECK-GI-NEXT:    mov s13, v1.s[3]
534; CHECK-GI-NEXT:    bl expf
535; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
536; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
537; CHECK-GI-NEXT:    fmov s0, s8
538; CHECK-GI-NEXT:    bl expf
539; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
540; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
541; CHECK-GI-NEXT:    fmov s0, s9
542; CHECK-GI-NEXT:    bl expf
543; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
544; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
545; CHECK-GI-NEXT:    fmov s0, s10
546; CHECK-GI-NEXT:    bl expf
547; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
548; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
549; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
550; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
551; CHECK-GI-NEXT:    bl expf
552; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
553; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
554; CHECK-GI-NEXT:    fmov s0, s11
555; CHECK-GI-NEXT:    bl expf
556; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
557; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
558; CHECK-GI-NEXT:    fmov s0, s12
559; CHECK-GI-NEXT:    bl expf
560; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
561; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
562; CHECK-GI-NEXT:    fmov s0, s13
563; CHECK-GI-NEXT:    bl expf
564; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
565; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
566; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
567; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
568; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
569; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
570; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
571; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
572; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
573; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
574; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
575; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
576; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
577; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
578; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
579; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
580; CHECK-GI-NEXT:    mov v2.16b, v1.16b
581; CHECK-GI-NEXT:    mov v1.16b, v3.16b
582; CHECK-GI-NEXT:    mov v0.16b, v2.16b
583; CHECK-GI-NEXT:    add sp, sp, #176
584; CHECK-GI-NEXT:    ret
585entry:
586  %c = call <8 x float> @llvm.exp.v8f32(<8 x float> %a)
587  ret <8 x float> %c
588}
589
590define <7 x half> @exp_v7f16(<7 x half> %a) {
591; CHECK-SD-LABEL: exp_v7f16:
592; CHECK-SD:       // %bb.0: // %entry
593; CHECK-SD-NEXT:    sub sp, sp, #48
594; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
595; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
596; CHECK-SD-NEXT:    .cfi_offset w30, -16
597; CHECK-SD-NEXT:    mov h1, v0.h[1]
598; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
599; CHECK-SD-NEXT:    fcvt s0, h1
600; CHECK-SD-NEXT:    bl expf
601; CHECK-SD-NEXT:    fcvt h0, s0
602; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
603; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
604; CHECK-SD-NEXT:    fcvt s0, h0
605; CHECK-SD-NEXT:    bl expf
606; CHECK-SD-NEXT:    fcvt h0, s0
607; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
608; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
609; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
610; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
611; CHECK-SD-NEXT:    mov h0, v0.h[2]
612; CHECK-SD-NEXT:    fcvt s0, h0
613; CHECK-SD-NEXT:    bl expf
614; CHECK-SD-NEXT:    fcvt h0, s0
615; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
616; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
617; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
618; CHECK-SD-NEXT:    mov h0, v0.h[3]
619; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
620; CHECK-SD-NEXT:    fcvt s0, h0
621; CHECK-SD-NEXT:    bl expf
622; CHECK-SD-NEXT:    fcvt h0, s0
623; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
624; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
625; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
626; CHECK-SD-NEXT:    mov h0, v0.h[4]
627; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
628; CHECK-SD-NEXT:    fcvt s0, h0
629; CHECK-SD-NEXT:    bl expf
630; CHECK-SD-NEXT:    fcvt h0, s0
631; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
632; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
633; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
634; CHECK-SD-NEXT:    mov h0, v0.h[5]
635; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
636; CHECK-SD-NEXT:    fcvt s0, h0
637; CHECK-SD-NEXT:    bl expf
638; CHECK-SD-NEXT:    fcvt h0, s0
639; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
640; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
641; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
642; CHECK-SD-NEXT:    mov h0, v0.h[6]
643; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
644; CHECK-SD-NEXT:    fcvt s0, h0
645; CHECK-SD-NEXT:    bl expf
646; CHECK-SD-NEXT:    fcvt h0, s0
647; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
648; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
649; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
650; CHECK-SD-NEXT:    mov h0, v0.h[7]
651; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
652; CHECK-SD-NEXT:    fcvt s0, h0
653; CHECK-SD-NEXT:    bl expf
654; CHECK-SD-NEXT:    fcvt h1, s0
655; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
656; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
657; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
658; CHECK-SD-NEXT:    add sp, sp, #48
659; CHECK-SD-NEXT:    ret
660;
661; CHECK-GI-LABEL: exp_v7f16:
662; CHECK-GI:       // %bb.0: // %entry
663; CHECK-GI-NEXT:    sub sp, sp, #160
664; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
665; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
666; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
667; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
668; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
669; CHECK-GI-NEXT:    .cfi_offset w30, -16
670; CHECK-GI-NEXT:    .cfi_offset b8, -24
671; CHECK-GI-NEXT:    .cfi_offset b9, -32
672; CHECK-GI-NEXT:    .cfi_offset b10, -40
673; CHECK-GI-NEXT:    .cfi_offset b11, -48
674; CHECK-GI-NEXT:    .cfi_offset b12, -56
675; CHECK-GI-NEXT:    .cfi_offset b13, -64
676; CHECK-GI-NEXT:    mov h8, v0.h[1]
677; CHECK-GI-NEXT:    mov h9, v0.h[2]
678; CHECK-GI-NEXT:    mov h10, v0.h[3]
679; CHECK-GI-NEXT:    mov h11, v0.h[4]
680; CHECK-GI-NEXT:    mov h12, v0.h[5]
681; CHECK-GI-NEXT:    mov h13, v0.h[6]
682; CHECK-GI-NEXT:    fcvt s0, h0
683; CHECK-GI-NEXT:    bl expf
684; CHECK-GI-NEXT:    fcvt s1, h8
685; CHECK-GI-NEXT:    fcvt h0, s0
686; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
687; CHECK-GI-NEXT:    fmov s0, s1
688; CHECK-GI-NEXT:    bl expf
689; CHECK-GI-NEXT:    fcvt s1, h9
690; CHECK-GI-NEXT:    fcvt h0, s0
691; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
692; CHECK-GI-NEXT:    fmov s0, s1
693; CHECK-GI-NEXT:    bl expf
694; CHECK-GI-NEXT:    fcvt s1, h10
695; CHECK-GI-NEXT:    fcvt h0, s0
696; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
697; CHECK-GI-NEXT:    fmov s0, s1
698; CHECK-GI-NEXT:    bl expf
699; CHECK-GI-NEXT:    fcvt s1, h11
700; CHECK-GI-NEXT:    fcvt h0, s0
701; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
702; CHECK-GI-NEXT:    fmov s0, s1
703; CHECK-GI-NEXT:    bl expf
704; CHECK-GI-NEXT:    fcvt s1, h12
705; CHECK-GI-NEXT:    fcvt h0, s0
706; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
707; CHECK-GI-NEXT:    fmov s0, s1
708; CHECK-GI-NEXT:    bl expf
709; CHECK-GI-NEXT:    fcvt s1, h13
710; CHECK-GI-NEXT:    fcvt h0, s0
711; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
712; CHECK-GI-NEXT:    fmov s0, s1
713; CHECK-GI-NEXT:    bl expf
714; CHECK-GI-NEXT:    ldp q3, q2, [sp, #48] // 32-byte Folded Reload
715; CHECK-GI-NEXT:    fcvt h0, s0
716; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
717; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
718; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
719; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
720; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
721; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
722; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
723; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
724; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
725; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
726; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
727; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
728; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
729; CHECK-GI-NEXT:    mov v0.16b, v1.16b
730; CHECK-GI-NEXT:    add sp, sp, #160
731; CHECK-GI-NEXT:    ret
732entry:
733  %c = call <7 x half> @llvm.exp.v7f16(<7 x half> %a)
734  ret <7 x half> %c
735}
736
737define <4 x half> @exp_v4f16(<4 x half> %a) {
738; CHECK-SD-LABEL: exp_v4f16:
739; CHECK-SD:       // %bb.0: // %entry
740; CHECK-SD-NEXT:    sub sp, sp, #48
741; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
742; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
743; CHECK-SD-NEXT:    .cfi_offset w30, -16
744; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
745; CHECK-SD-NEXT:    mov h1, v0.h[1]
746; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
747; CHECK-SD-NEXT:    fcvt s0, h1
748; CHECK-SD-NEXT:    bl expf
749; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
750; CHECK-SD-NEXT:    fcvt h0, s0
751; CHECK-SD-NEXT:    fcvt s1, h1
752; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
753; CHECK-SD-NEXT:    fmov s0, s1
754; CHECK-SD-NEXT:    bl expf
755; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
756; CHECK-SD-NEXT:    fcvt h2, s0
757; CHECK-SD-NEXT:    mov h1, v1.h[2]
758; CHECK-SD-NEXT:    fcvt s0, h1
759; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
760; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
761; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
762; CHECK-SD-NEXT:    bl expf
763; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
764; CHECK-SD-NEXT:    fcvt h2, s0
765; CHECK-SD-NEXT:    mov h1, v1.h[3]
766; CHECK-SD-NEXT:    fcvt s0, h1
767; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
768; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
769; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
770; CHECK-SD-NEXT:    bl expf
771; CHECK-SD-NEXT:    fcvt h1, s0
772; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
773; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
774; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
775; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
776; CHECK-SD-NEXT:    add sp, sp, #48
777; CHECK-SD-NEXT:    ret
778;
779; CHECK-GI-LABEL: exp_v4f16:
780; CHECK-GI:       // %bb.0: // %entry
781; CHECK-GI-NEXT:    sub sp, sp, #80
782; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
783; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
784; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
785; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
786; CHECK-GI-NEXT:    .cfi_offset w30, -8
787; CHECK-GI-NEXT:    .cfi_offset b8, -16
788; CHECK-GI-NEXT:    .cfi_offset b9, -24
789; CHECK-GI-NEXT:    .cfi_offset b10, -32
790; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
791; CHECK-GI-NEXT:    mov h8, v0.h[1]
792; CHECK-GI-NEXT:    mov h9, v0.h[2]
793; CHECK-GI-NEXT:    mov h10, v0.h[3]
794; CHECK-GI-NEXT:    fcvt s0, h0
795; CHECK-GI-NEXT:    bl expf
796; CHECK-GI-NEXT:    fcvt s1, h8
797; CHECK-GI-NEXT:    fcvt h0, s0
798; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
799; CHECK-GI-NEXT:    fmov s0, s1
800; CHECK-GI-NEXT:    bl expf
801; CHECK-GI-NEXT:    fcvt s1, h9
802; CHECK-GI-NEXT:    fcvt h0, s0
803; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
804; CHECK-GI-NEXT:    fmov s0, s1
805; CHECK-GI-NEXT:    bl expf
806; CHECK-GI-NEXT:    fcvt s1, h10
807; CHECK-GI-NEXT:    fcvt h0, s0
808; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
809; CHECK-GI-NEXT:    fmov s0, s1
810; CHECK-GI-NEXT:    bl expf
811; CHECK-GI-NEXT:    ldp q3, q2, [sp] // 32-byte Folded Reload
812; CHECK-GI-NEXT:    fcvt h0, s0
813; CHECK-GI-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
814; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
815; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
816; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
817; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
818; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
819; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
820; CHECK-GI-NEXT:    mov v0.16b, v1.16b
821; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
822; CHECK-GI-NEXT:    add sp, sp, #80
823; CHECK-GI-NEXT:    ret
824entry:
825  %c = call <4 x half> @llvm.exp.v4f16(<4 x half> %a)
826  ret <4 x half> %c
827}
828
829define <8 x half> @exp_v8f16(<8 x half> %a) {
830; CHECK-SD-LABEL: exp_v8f16:
831; CHECK-SD:       // %bb.0: // %entry
832; CHECK-SD-NEXT:    sub sp, sp, #48
833; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
834; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
835; CHECK-SD-NEXT:    .cfi_offset w30, -16
836; CHECK-SD-NEXT:    mov h1, v0.h[1]
837; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
838; CHECK-SD-NEXT:    fcvt s0, h1
839; CHECK-SD-NEXT:    bl expf
840; CHECK-SD-NEXT:    fcvt h0, s0
841; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
842; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
843; CHECK-SD-NEXT:    fcvt s0, h0
844; CHECK-SD-NEXT:    bl expf
845; CHECK-SD-NEXT:    fcvt h0, s0
846; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
847; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
848; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
849; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
850; CHECK-SD-NEXT:    mov h0, v0.h[2]
851; CHECK-SD-NEXT:    fcvt s0, h0
852; CHECK-SD-NEXT:    bl expf
853; CHECK-SD-NEXT:    fcvt h0, s0
854; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
855; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
856; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
857; CHECK-SD-NEXT:    mov h0, v0.h[3]
858; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
859; CHECK-SD-NEXT:    fcvt s0, h0
860; CHECK-SD-NEXT:    bl expf
861; CHECK-SD-NEXT:    fcvt h0, s0
862; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
863; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
864; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
865; CHECK-SD-NEXT:    mov h0, v0.h[4]
866; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
867; CHECK-SD-NEXT:    fcvt s0, h0
868; CHECK-SD-NEXT:    bl expf
869; CHECK-SD-NEXT:    fcvt h0, s0
870; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
871; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
872; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
873; CHECK-SD-NEXT:    mov h0, v0.h[5]
874; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
875; CHECK-SD-NEXT:    fcvt s0, h0
876; CHECK-SD-NEXT:    bl expf
877; CHECK-SD-NEXT:    fcvt h0, s0
878; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
879; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
880; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
881; CHECK-SD-NEXT:    mov h0, v0.h[6]
882; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
883; CHECK-SD-NEXT:    fcvt s0, h0
884; CHECK-SD-NEXT:    bl expf
885; CHECK-SD-NEXT:    fcvt h0, s0
886; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
887; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
888; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
889; CHECK-SD-NEXT:    mov h0, v0.h[7]
890; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
891; CHECK-SD-NEXT:    fcvt s0, h0
892; CHECK-SD-NEXT:    bl expf
893; CHECK-SD-NEXT:    fcvt h1, s0
894; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
895; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
896; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
897; CHECK-SD-NEXT:    add sp, sp, #48
898; CHECK-SD-NEXT:    ret
899;
900; CHECK-GI-LABEL: exp_v8f16:
901; CHECK-GI:       // %bb.0: // %entry
902; CHECK-GI-NEXT:    sub sp, sp, #176
903; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
904; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
905; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
906; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
907; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
908; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
909; CHECK-GI-NEXT:    .cfi_offset w30, -8
910; CHECK-GI-NEXT:    .cfi_offset b8, -16
911; CHECK-GI-NEXT:    .cfi_offset b9, -24
912; CHECK-GI-NEXT:    .cfi_offset b10, -32
913; CHECK-GI-NEXT:    .cfi_offset b11, -40
914; CHECK-GI-NEXT:    .cfi_offset b12, -48
915; CHECK-GI-NEXT:    .cfi_offset b13, -56
916; CHECK-GI-NEXT:    .cfi_offset b14, -64
917; CHECK-GI-NEXT:    mov h8, v0.h[1]
918; CHECK-GI-NEXT:    mov h9, v0.h[2]
919; CHECK-GI-NEXT:    mov h10, v0.h[3]
920; CHECK-GI-NEXT:    mov h11, v0.h[4]
921; CHECK-GI-NEXT:    mov h12, v0.h[5]
922; CHECK-GI-NEXT:    mov h13, v0.h[6]
923; CHECK-GI-NEXT:    mov h14, v0.h[7]
924; CHECK-GI-NEXT:    fcvt s0, h0
925; CHECK-GI-NEXT:    bl expf
926; CHECK-GI-NEXT:    fcvt s1, h8
927; CHECK-GI-NEXT:    fcvt h0, s0
928; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
929; CHECK-GI-NEXT:    fmov s0, s1
930; CHECK-GI-NEXT:    bl expf
931; CHECK-GI-NEXT:    fcvt s1, h9
932; CHECK-GI-NEXT:    fcvt h0, s0
933; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
934; CHECK-GI-NEXT:    fmov s0, s1
935; CHECK-GI-NEXT:    bl expf
936; CHECK-GI-NEXT:    fcvt s1, h10
937; CHECK-GI-NEXT:    fcvt h0, s0
938; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
939; CHECK-GI-NEXT:    fmov s0, s1
940; CHECK-GI-NEXT:    bl expf
941; CHECK-GI-NEXT:    fcvt s1, h11
942; CHECK-GI-NEXT:    fcvt h0, s0
943; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
944; CHECK-GI-NEXT:    fmov s0, s1
945; CHECK-GI-NEXT:    bl expf
946; CHECK-GI-NEXT:    fcvt s1, h12
947; CHECK-GI-NEXT:    fcvt h0, s0
948; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
949; CHECK-GI-NEXT:    fmov s0, s1
950; CHECK-GI-NEXT:    bl expf
951; CHECK-GI-NEXT:    fcvt s1, h13
952; CHECK-GI-NEXT:    fcvt h0, s0
953; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
954; CHECK-GI-NEXT:    fmov s0, s1
955; CHECK-GI-NEXT:    bl expf
956; CHECK-GI-NEXT:    fcvt s1, h14
957; CHECK-GI-NEXT:    fcvt h0, s0
958; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
959; CHECK-GI-NEXT:    fmov s0, s1
960; CHECK-GI-NEXT:    bl expf
961; CHECK-GI-NEXT:    ldp q3, q2, [sp, #64] // 32-byte Folded Reload
962; CHECK-GI-NEXT:    fcvt h0, s0
963; CHECK-GI-NEXT:    ldr q1, [sp, #96] // 16-byte Folded Reload
964; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
965; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
966; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
967; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
968; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
969; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
970; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
971; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
972; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
973; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
974; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
975; CHECK-GI-NEXT:    mov v1.h[5], v3.h[0]
976; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
977; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
978; CHECK-GI-NEXT:    mov v0.16b, v1.16b
979; CHECK-GI-NEXT:    add sp, sp, #176
980; CHECK-GI-NEXT:    ret
981entry:
982  %c = call <8 x half> @llvm.exp.v8f16(<8 x half> %a)
983  ret <8 x half> %c
984}
985
986define <16 x half> @exp_v16f16(<16 x half> %a) {
987; CHECK-SD-LABEL: exp_v16f16:
988; CHECK-SD:       // %bb.0: // %entry
989; CHECK-SD-NEXT:    sub sp, sp, #64
990; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
991; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
992; CHECK-SD-NEXT:    .cfi_offset w30, -16
993; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
994; CHECK-SD-NEXT:    mov h1, v0.h[1]
995; CHECK-SD-NEXT:    fcvt s0, h1
996; CHECK-SD-NEXT:    bl expf
997; CHECK-SD-NEXT:    fcvt h0, s0
998; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
999; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1000; CHECK-SD-NEXT:    fcvt s0, h0
1001; CHECK-SD-NEXT:    bl expf
1002; CHECK-SD-NEXT:    fcvt h0, s0
1003; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1004; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
1005; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1006; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1007; CHECK-SD-NEXT:    mov h0, v0.h[2]
1008; CHECK-SD-NEXT:    fcvt s0, h0
1009; CHECK-SD-NEXT:    bl expf
1010; CHECK-SD-NEXT:    fcvt h0, s0
1011; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1012; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
1013; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1014; CHECK-SD-NEXT:    mov h0, v0.h[3]
1015; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1016; CHECK-SD-NEXT:    fcvt s0, h0
1017; CHECK-SD-NEXT:    bl expf
1018; CHECK-SD-NEXT:    fcvt h0, s0
1019; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1020; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
1021; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1022; CHECK-SD-NEXT:    mov h0, v0.h[4]
1023; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1024; CHECK-SD-NEXT:    fcvt s0, h0
1025; CHECK-SD-NEXT:    bl expf
1026; CHECK-SD-NEXT:    fcvt h0, s0
1027; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1028; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
1029; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1030; CHECK-SD-NEXT:    mov h0, v0.h[5]
1031; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1032; CHECK-SD-NEXT:    fcvt s0, h0
1033; CHECK-SD-NEXT:    bl expf
1034; CHECK-SD-NEXT:    fcvt h0, s0
1035; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1036; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
1037; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1038; CHECK-SD-NEXT:    mov h0, v0.h[6]
1039; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1040; CHECK-SD-NEXT:    fcvt s0, h0
1041; CHECK-SD-NEXT:    bl expf
1042; CHECK-SD-NEXT:    fcvt h0, s0
1043; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1044; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
1045; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1046; CHECK-SD-NEXT:    mov h0, v0.h[7]
1047; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1048; CHECK-SD-NEXT:    fcvt s0, h0
1049; CHECK-SD-NEXT:    bl expf
1050; CHECK-SD-NEXT:    fcvt h0, s0
1051; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1052; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
1053; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1054; CHECK-SD-NEXT:    mov h0, v0.h[1]
1055; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1056; CHECK-SD-NEXT:    fcvt s0, h0
1057; CHECK-SD-NEXT:    bl expf
1058; CHECK-SD-NEXT:    fcvt h0, s0
1059; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1060; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1061; CHECK-SD-NEXT:    fcvt s0, h0
1062; CHECK-SD-NEXT:    bl expf
1063; CHECK-SD-NEXT:    fcvt h0, s0
1064; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1065; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
1066; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1067; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1068; CHECK-SD-NEXT:    mov h0, v0.h[2]
1069; CHECK-SD-NEXT:    fcvt s0, h0
1070; CHECK-SD-NEXT:    bl expf
1071; CHECK-SD-NEXT:    fcvt h0, s0
1072; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1073; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
1074; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1075; CHECK-SD-NEXT:    mov h0, v0.h[3]
1076; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1077; CHECK-SD-NEXT:    fcvt s0, h0
1078; CHECK-SD-NEXT:    bl expf
1079; CHECK-SD-NEXT:    fcvt h0, s0
1080; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1081; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
1082; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1083; CHECK-SD-NEXT:    mov h0, v0.h[4]
1084; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1085; CHECK-SD-NEXT:    fcvt s0, h0
1086; CHECK-SD-NEXT:    bl expf
1087; CHECK-SD-NEXT:    fcvt h0, s0
1088; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1089; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
1090; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1091; CHECK-SD-NEXT:    mov h0, v0.h[5]
1092; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1093; CHECK-SD-NEXT:    fcvt s0, h0
1094; CHECK-SD-NEXT:    bl expf
1095; CHECK-SD-NEXT:    fcvt h0, s0
1096; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1097; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
1098; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1099; CHECK-SD-NEXT:    mov h0, v0.h[6]
1100; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1101; CHECK-SD-NEXT:    fcvt s0, h0
1102; CHECK-SD-NEXT:    bl expf
1103; CHECK-SD-NEXT:    fcvt h0, s0
1104; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1105; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
1106; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1107; CHECK-SD-NEXT:    mov h0, v0.h[7]
1108; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1109; CHECK-SD-NEXT:    fcvt s0, h0
1110; CHECK-SD-NEXT:    bl expf
1111; CHECK-SD-NEXT:    fmov s1, s0
1112; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1113; CHECK-SD-NEXT:    fcvt h2, s1
1114; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
1115; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
1116; CHECK-SD-NEXT:    add sp, sp, #64
1117; CHECK-SD-NEXT:    ret
1118;
1119; CHECK-GI-LABEL: exp_v16f16:
1120; CHECK-GI:       // %bb.0: // %entry
1121; CHECK-GI-NEXT:    sub sp, sp, #320
1122; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
1123; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
1124; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
1125; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
1126; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
1127; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
1128; CHECK-GI-NEXT:    .cfi_offset w30, -8
1129; CHECK-GI-NEXT:    .cfi_offset w29, -16
1130; CHECK-GI-NEXT:    .cfi_offset b8, -24
1131; CHECK-GI-NEXT:    .cfi_offset b9, -32
1132; CHECK-GI-NEXT:    .cfi_offset b10, -40
1133; CHECK-GI-NEXT:    .cfi_offset b11, -48
1134; CHECK-GI-NEXT:    .cfi_offset b12, -56
1135; CHECK-GI-NEXT:    .cfi_offset b13, -64
1136; CHECK-GI-NEXT:    .cfi_offset b14, -72
1137; CHECK-GI-NEXT:    .cfi_offset b15, -80
1138; CHECK-GI-NEXT:    mov v2.16b, v1.16b
1139; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
1140; CHECK-GI-NEXT:    mov h14, v1.h[1]
1141; CHECK-GI-NEXT:    mov h1, v1.h[2]
1142; CHECK-GI-NEXT:    mov h15, v0.h[1]
1143; CHECK-GI-NEXT:    mov h8, v0.h[2]
1144; CHECK-GI-NEXT:    mov h9, v0.h[3]
1145; CHECK-GI-NEXT:    mov h10, v0.h[4]
1146; CHECK-GI-NEXT:    mov h11, v0.h[5]
1147; CHECK-GI-NEXT:    mov h12, v0.h[6]
1148; CHECK-GI-NEXT:    mov h13, v0.h[7]
1149; CHECK-GI-NEXT:    fcvt s0, h0
1150; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
1151; CHECK-GI-NEXT:    mov h1, v2.h[3]
1152; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
1153; CHECK-GI-NEXT:    mov h1, v2.h[4]
1154; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
1155; CHECK-GI-NEXT:    mov h1, v2.h[5]
1156; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
1157; CHECK-GI-NEXT:    mov h1, v2.h[6]
1158; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
1159; CHECK-GI-NEXT:    mov h1, v2.h[7]
1160; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
1161; CHECK-GI-NEXT:    bl expf
1162; CHECK-GI-NEXT:    fcvt s1, h15
1163; CHECK-GI-NEXT:    fcvt h0, s0
1164; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
1165; CHECK-GI-NEXT:    fmov s0, s1
1166; CHECK-GI-NEXT:    bl expf
1167; CHECK-GI-NEXT:    fcvt s1, h8
1168; CHECK-GI-NEXT:    fcvt h0, s0
1169; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
1170; CHECK-GI-NEXT:    fmov s0, s1
1171; CHECK-GI-NEXT:    bl expf
1172; CHECK-GI-NEXT:    fcvt s1, h9
1173; CHECK-GI-NEXT:    fcvt h0, s0
1174; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
1175; CHECK-GI-NEXT:    fmov s0, s1
1176; CHECK-GI-NEXT:    bl expf
1177; CHECK-GI-NEXT:    fcvt s1, h10
1178; CHECK-GI-NEXT:    fcvt h0, s0
1179; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
1180; CHECK-GI-NEXT:    fmov s0, s1
1181; CHECK-GI-NEXT:    bl expf
1182; CHECK-GI-NEXT:    fcvt s1, h11
1183; CHECK-GI-NEXT:    fcvt h0, s0
1184; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
1185; CHECK-GI-NEXT:    fmov s0, s1
1186; CHECK-GI-NEXT:    bl expf
1187; CHECK-GI-NEXT:    fcvt s1, h12
1188; CHECK-GI-NEXT:    fcvt h0, s0
1189; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
1190; CHECK-GI-NEXT:    fmov s0, s1
1191; CHECK-GI-NEXT:    bl expf
1192; CHECK-GI-NEXT:    fcvt s1, h13
1193; CHECK-GI-NEXT:    fcvt h0, s0
1194; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
1195; CHECK-GI-NEXT:    fmov s0, s1
1196; CHECK-GI-NEXT:    bl expf
1197; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
1198; CHECK-GI-NEXT:    fcvt h0, s0
1199; CHECK-GI-NEXT:    fcvt s1, h1
1200; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
1201; CHECK-GI-NEXT:    fmov s0, s1
1202; CHECK-GI-NEXT:    bl expf
1203; CHECK-GI-NEXT:    fcvt s1, h14
1204; CHECK-GI-NEXT:    fcvt h0, s0
1205; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1206; CHECK-GI-NEXT:    fmov s0, s1
1207; CHECK-GI-NEXT:    bl expf
1208; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
1209; CHECK-GI-NEXT:    fcvt h0, s0
1210; CHECK-GI-NEXT:    fcvt s1, h1
1211; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1212; CHECK-GI-NEXT:    fmov s0, s1
1213; CHECK-GI-NEXT:    bl expf
1214; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
1215; CHECK-GI-NEXT:    fcvt h0, s0
1216; CHECK-GI-NEXT:    fcvt s1, h1
1217; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1218; CHECK-GI-NEXT:    fmov s0, s1
1219; CHECK-GI-NEXT:    bl expf
1220; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
1221; CHECK-GI-NEXT:    fcvt h0, s0
1222; CHECK-GI-NEXT:    fcvt s1, h1
1223; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
1224; CHECK-GI-NEXT:    fmov s0, s1
1225; CHECK-GI-NEXT:    bl expf
1226; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
1227; CHECK-GI-NEXT:    fcvt h0, s0
1228; CHECK-GI-NEXT:    fcvt s1, h1
1229; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
1230; CHECK-GI-NEXT:    fmov s0, s1
1231; CHECK-GI-NEXT:    bl expf
1232; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
1233; CHECK-GI-NEXT:    fcvt h0, s0
1234; CHECK-GI-NEXT:    fcvt s1, h1
1235; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
1236; CHECK-GI-NEXT:    fmov s0, s1
1237; CHECK-GI-NEXT:    bl expf
1238; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
1239; CHECK-GI-NEXT:    fcvt h0, s0
1240; CHECK-GI-NEXT:    fcvt s1, h1
1241; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
1242; CHECK-GI-NEXT:    fmov s0, s1
1243; CHECK-GI-NEXT:    bl expf
1244; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
1245; CHECK-GI-NEXT:    ldr q2, [sp, #112] // 16-byte Folded Reload
1246; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
1247; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
1248; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
1249; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
1250; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
1251; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
1252; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
1253; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
1254; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
1255; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
1256; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
1257; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
1258; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
1259; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
1260; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
1261; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
1262; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
1263; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
1264; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
1265; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
1266; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
1267; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
1268; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
1269; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
1270; CHECK-GI-NEXT:    fcvt h2, s0
1271; CHECK-GI-NEXT:    ldr q0, [sp, #128] // 16-byte Folded Reload
1272; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
1273; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
1274; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
1275; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
1276; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
1277; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
1278; CHECK-GI-NEXT:    mov v0.16b, v3.16b
1279; CHECK-GI-NEXT:    add sp, sp, #320
1280; CHECK-GI-NEXT:    ret
1281entry:
1282  %c = call <16 x half> @llvm.exp.v16f16(<16 x half> %a)
1283  ret <16 x half> %c
1284}
1285
1286define <2 x fp128> @exp_v2fp128(<2 x fp128> %a) {
1287; CHECK-LABEL: exp_v2fp128:
1288; CHECK:       // %bb.0: // %entry
1289; CHECK-NEXT:    sub sp, sp, #48
1290; CHECK-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1291; CHECK-NEXT:    .cfi_def_cfa_offset 48
1292; CHECK-NEXT:    .cfi_offset w30, -16
1293; CHECK-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1294; CHECK-NEXT:    bl expl
1295; CHECK-NEXT:    str q0, [sp] // 16-byte Folded Spill
1296; CHECK-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1297; CHECK-NEXT:    bl expl
1298; CHECK-NEXT:    mov v1.16b, v0.16b
1299; CHECK-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1300; CHECK-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1301; CHECK-NEXT:    add sp, sp, #48
1302; CHECK-NEXT:    ret
1303entry:
1304  %c = call <2 x fp128> @llvm.exp.v2fp128(<2 x fp128> %a)
1305  ret <2 x fp128> %c
1306}
1307
1308define double @exp2_f64(double %a) {
1309; CHECK-LABEL: exp2_f64:
1310; CHECK:       // %bb.0: // %entry
1311; CHECK-NEXT:    b exp2
1312entry:
1313  %c = call double @llvm.exp2.f64(double %a)
1314  ret double %c
1315}
1316
1317define float @exp2_f32(float %a) {
1318; CHECK-LABEL: exp2_f32:
1319; CHECK:       // %bb.0: // %entry
1320; CHECK-NEXT:    b exp2f
1321entry:
1322  %c = call float @llvm.exp2.f32(float %a)
1323  ret float %c
1324}
1325
1326define half @exp2_f16(half %a) {
1327; CHECK-LABEL: exp2_f16:
1328; CHECK:       // %bb.0: // %entry
1329; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
1330; CHECK-NEXT:    .cfi_def_cfa_offset 16
1331; CHECK-NEXT:    .cfi_offset w30, -16
1332; CHECK-NEXT:    fcvt s0, h0
1333; CHECK-NEXT:    bl exp2f
1334; CHECK-NEXT:    fcvt h0, s0
1335; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
1336; CHECK-NEXT:    ret
1337entry:
1338  %c = call half @llvm.exp2.f16(half %a)
1339  ret half %c
1340}
1341
1342define fp128 @exp2_fp128(fp128 %a) {
1343; CHECK-LABEL: exp2_fp128:
1344; CHECK:       // %bb.0: // %entry
1345; CHECK-NEXT:    b exp2l
1346entry:
1347  %c = call fp128 @llvm.exp2.fp128(fp128 %a)
1348  ret fp128 %c
1349}
1350
1351define <1 x double> @exp2_v1f64(<1 x double> %a) {
1352; CHECK-LABEL: exp2_v1f64:
1353; CHECK:       // %bb.0: // %entry
1354; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
1355; CHECK-NEXT:    .cfi_def_cfa_offset 16
1356; CHECK-NEXT:    .cfi_offset w30, -16
1357; CHECK-NEXT:    bl exp2
1358; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
1359; CHECK-NEXT:    ret
1360entry:
1361  %c = call <1 x double> @llvm.exp2.v1f64(<1 x double> %a)
1362  ret <1 x double> %c
1363}
1364
1365define <2 x double> @exp2_v2f64(<2 x double> %a) {
1366; CHECK-SD-LABEL: exp2_v2f64:
1367; CHECK-SD:       // %bb.0: // %entry
1368; CHECK-SD-NEXT:    sub sp, sp, #48
1369; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1370; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1371; CHECK-SD-NEXT:    .cfi_offset w30, -16
1372; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1373; CHECK-SD-NEXT:    mov d0, v0.d[1]
1374; CHECK-SD-NEXT:    bl exp2
1375; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1376; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1377; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1378; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1379; CHECK-SD-NEXT:    bl exp2
1380; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1381; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1382; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1383; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
1384; CHECK-SD-NEXT:    add sp, sp, #48
1385; CHECK-SD-NEXT:    ret
1386;
1387; CHECK-GI-LABEL: exp2_v2f64:
1388; CHECK-GI:       // %bb.0: // %entry
1389; CHECK-GI-NEXT:    sub sp, sp, #32
1390; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
1391; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1392; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
1393; CHECK-GI-NEXT:    .cfi_offset w30, -8
1394; CHECK-GI-NEXT:    .cfi_offset b8, -16
1395; CHECK-GI-NEXT:    mov d8, v0.d[1]
1396; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1397; CHECK-GI-NEXT:    bl exp2
1398; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1399; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1400; CHECK-GI-NEXT:    fmov d0, d8
1401; CHECK-GI-NEXT:    bl exp2
1402; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1403; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1404; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1405; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
1406; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
1407; CHECK-GI-NEXT:    mov v0.16b, v1.16b
1408; CHECK-GI-NEXT:    add sp, sp, #32
1409; CHECK-GI-NEXT:    ret
1410entry:
1411  %c = call <2 x double> @llvm.exp2.v2f64(<2 x double> %a)
1412  ret <2 x double> %c
1413}
1414
1415define <3 x double> @exp2_v3f64(<3 x double> %a) {
1416; CHECK-SD-LABEL: exp2_v3f64:
1417; CHECK-SD:       // %bb.0: // %entry
1418; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
1419; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
1420; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1421; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
1422; CHECK-SD-NEXT:    .cfi_offset w30, -8
1423; CHECK-SD-NEXT:    .cfi_offset b8, -16
1424; CHECK-SD-NEXT:    .cfi_offset b9, -24
1425; CHECK-SD-NEXT:    .cfi_offset b10, -32
1426; CHECK-SD-NEXT:    fmov d8, d2
1427; CHECK-SD-NEXT:    fmov d9, d1
1428; CHECK-SD-NEXT:    bl exp2
1429; CHECK-SD-NEXT:    fmov d10, d0
1430; CHECK-SD-NEXT:    fmov d0, d9
1431; CHECK-SD-NEXT:    bl exp2
1432; CHECK-SD-NEXT:    fmov d9, d0
1433; CHECK-SD-NEXT:    fmov d0, d8
1434; CHECK-SD-NEXT:    bl exp2
1435; CHECK-SD-NEXT:    fmov d1, d9
1436; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
1437; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1438; CHECK-SD-NEXT:    fmov d2, d0
1439; CHECK-SD-NEXT:    fmov d0, d10
1440; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
1441; CHECK-SD-NEXT:    ret
1442;
1443; CHECK-GI-LABEL: exp2_v3f64:
1444; CHECK-GI:       // %bb.0: // %entry
1445; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
1446; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
1447; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1448; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
1449; CHECK-GI-NEXT:    .cfi_offset w30, -8
1450; CHECK-GI-NEXT:    .cfi_offset b8, -16
1451; CHECK-GI-NEXT:    .cfi_offset b9, -24
1452; CHECK-GI-NEXT:    .cfi_offset b10, -32
1453; CHECK-GI-NEXT:    fmov d8, d1
1454; CHECK-GI-NEXT:    fmov d9, d2
1455; CHECK-GI-NEXT:    bl exp2
1456; CHECK-GI-NEXT:    fmov d10, d0
1457; CHECK-GI-NEXT:    fmov d0, d8
1458; CHECK-GI-NEXT:    bl exp2
1459; CHECK-GI-NEXT:    fmov d8, d0
1460; CHECK-GI-NEXT:    fmov d0, d9
1461; CHECK-GI-NEXT:    bl exp2
1462; CHECK-GI-NEXT:    fmov d1, d8
1463; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
1464; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1465; CHECK-GI-NEXT:    fmov d2, d0
1466; CHECK-GI-NEXT:    fmov d0, d10
1467; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
1468; CHECK-GI-NEXT:    ret
1469entry:
1470  %c = call <3 x double> @llvm.exp2.v3f64(<3 x double> %a)
1471  ret <3 x double> %c
1472}
1473
1474define <4 x double> @exp2_v4f64(<4 x double> %a) {
1475; CHECK-SD-LABEL: exp2_v4f64:
1476; CHECK-SD:       // %bb.0: // %entry
1477; CHECK-SD-NEXT:    sub sp, sp, #64
1478; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
1479; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
1480; CHECK-SD-NEXT:    .cfi_offset w30, -16
1481; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1482; CHECK-SD-NEXT:    mov d0, v0.d[1]
1483; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1484; CHECK-SD-NEXT:    bl exp2
1485; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1486; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1487; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1488; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1489; CHECK-SD-NEXT:    bl exp2
1490; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1491; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1492; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
1493; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1494; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1495; CHECK-SD-NEXT:    mov d0, v0.d[1]
1496; CHECK-SD-NEXT:    bl exp2
1497; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1498; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1499; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1500; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1501; CHECK-SD-NEXT:    bl exp2
1502; CHECK-SD-NEXT:    fmov d1, d0
1503; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
1504; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1505; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
1506; CHECK-SD-NEXT:    add sp, sp, #64
1507; CHECK-SD-NEXT:    ret
1508;
1509; CHECK-GI-LABEL: exp2_v4f64:
1510; CHECK-GI:       // %bb.0: // %entry
1511; CHECK-GI-NEXT:    sub sp, sp, #80
1512; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
1513; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
1514; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
1515; CHECK-GI-NEXT:    .cfi_offset w30, -16
1516; CHECK-GI-NEXT:    .cfi_offset b8, -24
1517; CHECK-GI-NEXT:    .cfi_offset b9, -32
1518; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
1519; CHECK-GI-NEXT:    mov d8, v0.d[1]
1520; CHECK-GI-NEXT:    mov d9, v1.d[1]
1521; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1522; CHECK-GI-NEXT:    bl exp2
1523; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1524; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1525; CHECK-GI-NEXT:    fmov d0, d8
1526; CHECK-GI-NEXT:    bl exp2
1527; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1528; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1529; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1530; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
1531; CHECK-GI-NEXT:    bl exp2
1532; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1533; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1534; CHECK-GI-NEXT:    fmov d0, d9
1535; CHECK-GI-NEXT:    bl exp2
1536; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
1537; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1538; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
1539; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
1540; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
1541; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1542; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
1543; CHECK-GI-NEXT:    mov v0.16b, v2.16b
1544; CHECK-GI-NEXT:    add sp, sp, #80
1545; CHECK-GI-NEXT:    ret
1546entry:
1547  %c = call <4 x double> @llvm.exp2.v4f64(<4 x double> %a)
1548  ret <4 x double> %c
1549}
1550
1551define <2 x float> @exp2_v2f32(<2 x float> %a) {
1552; CHECK-SD-LABEL: exp2_v2f32:
1553; CHECK-SD:       // %bb.0: // %entry
1554; CHECK-SD-NEXT:    sub sp, sp, #48
1555; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1556; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1557; CHECK-SD-NEXT:    .cfi_offset w30, -16
1558; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
1559; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1560; CHECK-SD-NEXT:    mov s0, v0.s[1]
1561; CHECK-SD-NEXT:    bl exp2f
1562; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1563; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1564; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1565; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1566; CHECK-SD-NEXT:    bl exp2f
1567; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1568; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1569; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1570; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1571; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
1572; CHECK-SD-NEXT:    add sp, sp, #48
1573; CHECK-SD-NEXT:    ret
1574;
1575; CHECK-GI-LABEL: exp2_v2f32:
1576; CHECK-GI:       // %bb.0: // %entry
1577; CHECK-GI-NEXT:    sub sp, sp, #32
1578; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
1579; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
1580; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
1581; CHECK-GI-NEXT:    .cfi_offset w30, -8
1582; CHECK-GI-NEXT:    .cfi_offset b8, -16
1583; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
1584; CHECK-GI-NEXT:    mov s8, v0.s[1]
1585; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1586; CHECK-GI-NEXT:    bl exp2f
1587; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1588; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1589; CHECK-GI-NEXT:    fmov s0, s8
1590; CHECK-GI-NEXT:    bl exp2f
1591; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1592; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1593; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
1594; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
1595; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
1596; CHECK-GI-NEXT:    fmov d0, d1
1597; CHECK-GI-NEXT:    add sp, sp, #32
1598; CHECK-GI-NEXT:    ret
1599entry:
1600  %c = call <2 x float> @llvm.exp2.v2f32(<2 x float> %a)
1601  ret <2 x float> %c
1602}
1603
1604define <3 x float> @exp2_v3f32(<3 x float> %a) {
1605; CHECK-SD-LABEL: exp2_v3f32:
1606; CHECK-SD:       // %bb.0: // %entry
1607; CHECK-SD-NEXT:    sub sp, sp, #48
1608; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1609; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1610; CHECK-SD-NEXT:    .cfi_offset w30, -16
1611; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1612; CHECK-SD-NEXT:    mov s0, v0.s[1]
1613; CHECK-SD-NEXT:    bl exp2f
1614; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1615; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1616; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1617; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1618; CHECK-SD-NEXT:    bl exp2f
1619; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1620; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1621; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1622; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1623; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1624; CHECK-SD-NEXT:    mov s0, v0.s[2]
1625; CHECK-SD-NEXT:    bl exp2f
1626; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1627; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1628; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1629; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
1630; CHECK-SD-NEXT:    mov v0.16b, v1.16b
1631; CHECK-SD-NEXT:    add sp, sp, #48
1632; CHECK-SD-NEXT:    ret
1633;
1634; CHECK-GI-LABEL: exp2_v3f32:
1635; CHECK-GI:       // %bb.0: // %entry
1636; CHECK-GI-NEXT:    sub sp, sp, #64
1637; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
1638; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
1639; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
1640; CHECK-GI-NEXT:    .cfi_offset w30, -16
1641; CHECK-GI-NEXT:    .cfi_offset b8, -24
1642; CHECK-GI-NEXT:    .cfi_offset b9, -32
1643; CHECK-GI-NEXT:    mov s8, v0.s[1]
1644; CHECK-GI-NEXT:    mov s9, v0.s[2]
1645; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1646; CHECK-GI-NEXT:    bl exp2f
1647; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1648; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1649; CHECK-GI-NEXT:    fmov s0, s8
1650; CHECK-GI-NEXT:    bl exp2f
1651; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1652; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1653; CHECK-GI-NEXT:    fmov s0, s9
1654; CHECK-GI-NEXT:    bl exp2f
1655; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
1656; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1657; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1658; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
1659; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
1660; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
1661; CHECK-GI-NEXT:    mov v0.16b, v1.16b
1662; CHECK-GI-NEXT:    add sp, sp, #64
1663; CHECK-GI-NEXT:    ret
1664entry:
1665  %c = call <3 x float> @llvm.exp2.v3f32(<3 x float> %a)
1666  ret <3 x float> %c
1667}
1668
1669define <4 x float> @exp2_v4f32(<4 x float> %a) {
1670; CHECK-SD-LABEL: exp2_v4f32:
1671; CHECK-SD:       // %bb.0: // %entry
1672; CHECK-SD-NEXT:    sub sp, sp, #48
1673; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1674; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1675; CHECK-SD-NEXT:    .cfi_offset w30, -16
1676; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1677; CHECK-SD-NEXT:    mov s0, v0.s[1]
1678; CHECK-SD-NEXT:    bl exp2f
1679; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1680; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1681; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1682; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1683; CHECK-SD-NEXT:    bl exp2f
1684; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1685; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1686; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1687; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1688; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1689; CHECK-SD-NEXT:    mov s0, v0.s[2]
1690; CHECK-SD-NEXT:    bl exp2f
1691; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1692; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1693; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
1694; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1695; CHECK-SD-NEXT:    mov s0, v0.s[3]
1696; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
1697; CHECK-SD-NEXT:    bl exp2f
1698; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1699; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1700; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1701; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
1702; CHECK-SD-NEXT:    mov v0.16b, v1.16b
1703; CHECK-SD-NEXT:    add sp, sp, #48
1704; CHECK-SD-NEXT:    ret
1705;
1706; CHECK-GI-LABEL: exp2_v4f32:
1707; CHECK-GI:       // %bb.0: // %entry
1708; CHECK-GI-NEXT:    sub sp, sp, #80
1709; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
1710; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
1711; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
1712; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
1713; CHECK-GI-NEXT:    .cfi_offset w30, -8
1714; CHECK-GI-NEXT:    .cfi_offset b8, -16
1715; CHECK-GI-NEXT:    .cfi_offset b9, -24
1716; CHECK-GI-NEXT:    .cfi_offset b10, -32
1717; CHECK-GI-NEXT:    mov s8, v0.s[1]
1718; CHECK-GI-NEXT:    mov s9, v0.s[2]
1719; CHECK-GI-NEXT:    mov s10, v0.s[3]
1720; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1721; CHECK-GI-NEXT:    bl exp2f
1722; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1723; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1724; CHECK-GI-NEXT:    fmov s0, s8
1725; CHECK-GI-NEXT:    bl exp2f
1726; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1727; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1728; CHECK-GI-NEXT:    fmov s0, s9
1729; CHECK-GI-NEXT:    bl exp2f
1730; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1731; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1732; CHECK-GI-NEXT:    fmov s0, s10
1733; CHECK-GI-NEXT:    bl exp2f
1734; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
1735; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1736; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
1737; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
1738; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
1739; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
1740; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
1741; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
1742; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
1743; CHECK-GI-NEXT:    mov v0.16b, v1.16b
1744; CHECK-GI-NEXT:    add sp, sp, #80
1745; CHECK-GI-NEXT:    ret
1746entry:
1747  %c = call <4 x float> @llvm.exp2.v4f32(<4 x float> %a)
1748  ret <4 x float> %c
1749}
1750
1751define <8 x float> @exp2_v8f32(<8 x float> %a) {
1752; CHECK-SD-LABEL: exp2_v8f32:
1753; CHECK-SD:       // %bb.0: // %entry
1754; CHECK-SD-NEXT:    sub sp, sp, #64
1755; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
1756; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
1757; CHECK-SD-NEXT:    .cfi_offset w30, -16
1758; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
1759; CHECK-SD-NEXT:    mov s0, v0.s[1]
1760; CHECK-SD-NEXT:    bl exp2f
1761; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1762; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1763; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1764; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1765; CHECK-SD-NEXT:    bl exp2f
1766; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1767; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1768; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1769; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1770; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1771; CHECK-SD-NEXT:    mov s0, v0.s[2]
1772; CHECK-SD-NEXT:    bl exp2f
1773; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1774; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1775; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
1776; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1777; CHECK-SD-NEXT:    mov s0, v0.s[3]
1778; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1779; CHECK-SD-NEXT:    bl exp2f
1780; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
1781; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1782; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
1783; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1784; CHECK-SD-NEXT:    mov s0, v0.s[1]
1785; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1786; CHECK-SD-NEXT:    bl exp2f
1787; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1788; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1789; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1790; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
1791; CHECK-SD-NEXT:    bl exp2f
1792; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1793; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1794; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
1795; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1796; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1797; CHECK-SD-NEXT:    mov s0, v0.s[2]
1798; CHECK-SD-NEXT:    bl exp2f
1799; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1800; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
1801; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
1802; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1803; CHECK-SD-NEXT:    mov s0, v0.s[3]
1804; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
1805; CHECK-SD-NEXT:    bl exp2f
1806; CHECK-SD-NEXT:    fmov s2, s0
1807; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
1808; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1809; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
1810; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
1811; CHECK-SD-NEXT:    add sp, sp, #64
1812; CHECK-SD-NEXT:    ret
1813;
1814; CHECK-GI-LABEL: exp2_v8f32:
1815; CHECK-GI:       // %bb.0: // %entry
1816; CHECK-GI-NEXT:    sub sp, sp, #176
1817; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
1818; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
1819; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
1820; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
1821; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
1822; CHECK-GI-NEXT:    .cfi_offset w30, -16
1823; CHECK-GI-NEXT:    .cfi_offset b8, -24
1824; CHECK-GI-NEXT:    .cfi_offset b9, -32
1825; CHECK-GI-NEXT:    .cfi_offset b10, -40
1826; CHECK-GI-NEXT:    .cfi_offset b11, -48
1827; CHECK-GI-NEXT:    .cfi_offset b12, -56
1828; CHECK-GI-NEXT:    .cfi_offset b13, -64
1829; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
1830; CHECK-GI-NEXT:    mov s8, v0.s[1]
1831; CHECK-GI-NEXT:    mov s9, v0.s[2]
1832; CHECK-GI-NEXT:    mov s10, v0.s[3]
1833; CHECK-GI-NEXT:    mov s11, v1.s[1]
1834; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1835; CHECK-GI-NEXT:    mov s12, v1.s[2]
1836; CHECK-GI-NEXT:    mov s13, v1.s[3]
1837; CHECK-GI-NEXT:    bl exp2f
1838; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1839; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
1840; CHECK-GI-NEXT:    fmov s0, s8
1841; CHECK-GI-NEXT:    bl exp2f
1842; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1843; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
1844; CHECK-GI-NEXT:    fmov s0, s9
1845; CHECK-GI-NEXT:    bl exp2f
1846; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1847; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
1848; CHECK-GI-NEXT:    fmov s0, s10
1849; CHECK-GI-NEXT:    bl exp2f
1850; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1851; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
1852; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
1853; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
1854; CHECK-GI-NEXT:    bl exp2f
1855; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1856; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
1857; CHECK-GI-NEXT:    fmov s0, s11
1858; CHECK-GI-NEXT:    bl exp2f
1859; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1860; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1861; CHECK-GI-NEXT:    fmov s0, s12
1862; CHECK-GI-NEXT:    bl exp2f
1863; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1864; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
1865; CHECK-GI-NEXT:    fmov s0, s13
1866; CHECK-GI-NEXT:    bl exp2f
1867; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
1868; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
1869; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
1870; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
1871; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
1872; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
1873; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
1874; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
1875; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
1876; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
1877; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
1878; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
1879; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
1880; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
1881; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
1882; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
1883; CHECK-GI-NEXT:    mov v2.16b, v1.16b
1884; CHECK-GI-NEXT:    mov v1.16b, v3.16b
1885; CHECK-GI-NEXT:    mov v0.16b, v2.16b
1886; CHECK-GI-NEXT:    add sp, sp, #176
1887; CHECK-GI-NEXT:    ret
1888entry:
1889  %c = call <8 x float> @llvm.exp2.v8f32(<8 x float> %a)
1890  ret <8 x float> %c
1891}
1892
1893define <7 x half> @exp2_v7f16(<7 x half> %a) {
1894; CHECK-SD-LABEL: exp2_v7f16:
1895; CHECK-SD:       // %bb.0: // %entry
1896; CHECK-SD-NEXT:    sub sp, sp, #48
1897; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
1898; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
1899; CHECK-SD-NEXT:    .cfi_offset w30, -16
1900; CHECK-SD-NEXT:    mov h1, v0.h[1]
1901; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
1902; CHECK-SD-NEXT:    fcvt s0, h1
1903; CHECK-SD-NEXT:    bl exp2f
1904; CHECK-SD-NEXT:    fcvt h0, s0
1905; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1906; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1907; CHECK-SD-NEXT:    fcvt s0, h0
1908; CHECK-SD-NEXT:    bl exp2f
1909; CHECK-SD-NEXT:    fcvt h0, s0
1910; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1911; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
1912; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
1913; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1914; CHECK-SD-NEXT:    mov h0, v0.h[2]
1915; CHECK-SD-NEXT:    fcvt s0, h0
1916; CHECK-SD-NEXT:    bl exp2f
1917; CHECK-SD-NEXT:    fcvt h0, s0
1918; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1919; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
1920; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1921; CHECK-SD-NEXT:    mov h0, v0.h[3]
1922; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1923; CHECK-SD-NEXT:    fcvt s0, h0
1924; CHECK-SD-NEXT:    bl exp2f
1925; CHECK-SD-NEXT:    fcvt h0, s0
1926; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1927; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
1928; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1929; CHECK-SD-NEXT:    mov h0, v0.h[4]
1930; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1931; CHECK-SD-NEXT:    fcvt s0, h0
1932; CHECK-SD-NEXT:    bl exp2f
1933; CHECK-SD-NEXT:    fcvt h0, s0
1934; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1935; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
1936; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1937; CHECK-SD-NEXT:    mov h0, v0.h[5]
1938; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1939; CHECK-SD-NEXT:    fcvt s0, h0
1940; CHECK-SD-NEXT:    bl exp2f
1941; CHECK-SD-NEXT:    fcvt h0, s0
1942; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1943; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
1944; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1945; CHECK-SD-NEXT:    mov h0, v0.h[6]
1946; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1947; CHECK-SD-NEXT:    fcvt s0, h0
1948; CHECK-SD-NEXT:    bl exp2f
1949; CHECK-SD-NEXT:    fcvt h0, s0
1950; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
1951; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
1952; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
1953; CHECK-SD-NEXT:    mov h0, v0.h[7]
1954; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
1955; CHECK-SD-NEXT:    fcvt s0, h0
1956; CHECK-SD-NEXT:    bl exp2f
1957; CHECK-SD-NEXT:    fcvt h1, s0
1958; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
1959; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
1960; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
1961; CHECK-SD-NEXT:    add sp, sp, #48
1962; CHECK-SD-NEXT:    ret
1963;
1964; CHECK-GI-LABEL: exp2_v7f16:
1965; CHECK-GI:       // %bb.0: // %entry
1966; CHECK-GI-NEXT:    sub sp, sp, #160
1967; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
1968; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
1969; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
1970; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
1971; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
1972; CHECK-GI-NEXT:    .cfi_offset w30, -16
1973; CHECK-GI-NEXT:    .cfi_offset b8, -24
1974; CHECK-GI-NEXT:    .cfi_offset b9, -32
1975; CHECK-GI-NEXT:    .cfi_offset b10, -40
1976; CHECK-GI-NEXT:    .cfi_offset b11, -48
1977; CHECK-GI-NEXT:    .cfi_offset b12, -56
1978; CHECK-GI-NEXT:    .cfi_offset b13, -64
1979; CHECK-GI-NEXT:    mov h8, v0.h[1]
1980; CHECK-GI-NEXT:    mov h9, v0.h[2]
1981; CHECK-GI-NEXT:    mov h10, v0.h[3]
1982; CHECK-GI-NEXT:    mov h11, v0.h[4]
1983; CHECK-GI-NEXT:    mov h12, v0.h[5]
1984; CHECK-GI-NEXT:    mov h13, v0.h[6]
1985; CHECK-GI-NEXT:    fcvt s0, h0
1986; CHECK-GI-NEXT:    bl exp2f
1987; CHECK-GI-NEXT:    fcvt s1, h8
1988; CHECK-GI-NEXT:    fcvt h0, s0
1989; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
1990; CHECK-GI-NEXT:    fmov s0, s1
1991; CHECK-GI-NEXT:    bl exp2f
1992; CHECK-GI-NEXT:    fcvt s1, h9
1993; CHECK-GI-NEXT:    fcvt h0, s0
1994; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
1995; CHECK-GI-NEXT:    fmov s0, s1
1996; CHECK-GI-NEXT:    bl exp2f
1997; CHECK-GI-NEXT:    fcvt s1, h10
1998; CHECK-GI-NEXT:    fcvt h0, s0
1999; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
2000; CHECK-GI-NEXT:    fmov s0, s1
2001; CHECK-GI-NEXT:    bl exp2f
2002; CHECK-GI-NEXT:    fcvt s1, h11
2003; CHECK-GI-NEXT:    fcvt h0, s0
2004; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2005; CHECK-GI-NEXT:    fmov s0, s1
2006; CHECK-GI-NEXT:    bl exp2f
2007; CHECK-GI-NEXT:    fcvt s1, h12
2008; CHECK-GI-NEXT:    fcvt h0, s0
2009; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2010; CHECK-GI-NEXT:    fmov s0, s1
2011; CHECK-GI-NEXT:    bl exp2f
2012; CHECK-GI-NEXT:    fcvt s1, h13
2013; CHECK-GI-NEXT:    fcvt h0, s0
2014; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2015; CHECK-GI-NEXT:    fmov s0, s1
2016; CHECK-GI-NEXT:    bl exp2f
2017; CHECK-GI-NEXT:    ldp q3, q2, [sp, #48] // 32-byte Folded Reload
2018; CHECK-GI-NEXT:    fcvt h0, s0
2019; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
2020; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
2021; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
2022; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
2023; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
2024; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
2025; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
2026; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
2027; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
2028; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
2029; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
2030; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
2031; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
2032; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2033; CHECK-GI-NEXT:    add sp, sp, #160
2034; CHECK-GI-NEXT:    ret
2035entry:
2036  %c = call <7 x half> @llvm.exp2.v7f16(<7 x half> %a)
2037  ret <7 x half> %c
2038}
2039
2040define <4 x half> @exp2_v4f16(<4 x half> %a) {
2041; CHECK-SD-LABEL: exp2_v4f16:
2042; CHECK-SD:       // %bb.0: // %entry
2043; CHECK-SD-NEXT:    sub sp, sp, #48
2044; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2045; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2046; CHECK-SD-NEXT:    .cfi_offset w30, -16
2047; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2048; CHECK-SD-NEXT:    mov h1, v0.h[1]
2049; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2050; CHECK-SD-NEXT:    fcvt s0, h1
2051; CHECK-SD-NEXT:    bl exp2f
2052; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2053; CHECK-SD-NEXT:    fcvt h0, s0
2054; CHECK-SD-NEXT:    fcvt s1, h1
2055; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2056; CHECK-SD-NEXT:    fmov s0, s1
2057; CHECK-SD-NEXT:    bl exp2f
2058; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2059; CHECK-SD-NEXT:    fcvt h2, s0
2060; CHECK-SD-NEXT:    mov h1, v1.h[2]
2061; CHECK-SD-NEXT:    fcvt s0, h1
2062; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2063; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
2064; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
2065; CHECK-SD-NEXT:    bl exp2f
2066; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2067; CHECK-SD-NEXT:    fcvt h2, s0
2068; CHECK-SD-NEXT:    mov h1, v1.h[3]
2069; CHECK-SD-NEXT:    fcvt s0, h1
2070; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2071; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
2072; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
2073; CHECK-SD-NEXT:    bl exp2f
2074; CHECK-SD-NEXT:    fcvt h1, s0
2075; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2076; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2077; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
2078; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2079; CHECK-SD-NEXT:    add sp, sp, #48
2080; CHECK-SD-NEXT:    ret
2081;
2082; CHECK-GI-LABEL: exp2_v4f16:
2083; CHECK-GI:       // %bb.0: // %entry
2084; CHECK-GI-NEXT:    sub sp, sp, #80
2085; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
2086; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
2087; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
2088; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
2089; CHECK-GI-NEXT:    .cfi_offset w30, -8
2090; CHECK-GI-NEXT:    .cfi_offset b8, -16
2091; CHECK-GI-NEXT:    .cfi_offset b9, -24
2092; CHECK-GI-NEXT:    .cfi_offset b10, -32
2093; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2094; CHECK-GI-NEXT:    mov h8, v0.h[1]
2095; CHECK-GI-NEXT:    mov h9, v0.h[2]
2096; CHECK-GI-NEXT:    mov h10, v0.h[3]
2097; CHECK-GI-NEXT:    fcvt s0, h0
2098; CHECK-GI-NEXT:    bl exp2f
2099; CHECK-GI-NEXT:    fcvt s1, h8
2100; CHECK-GI-NEXT:    fcvt h0, s0
2101; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2102; CHECK-GI-NEXT:    fmov s0, s1
2103; CHECK-GI-NEXT:    bl exp2f
2104; CHECK-GI-NEXT:    fcvt s1, h9
2105; CHECK-GI-NEXT:    fcvt h0, s0
2106; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2107; CHECK-GI-NEXT:    fmov s0, s1
2108; CHECK-GI-NEXT:    bl exp2f
2109; CHECK-GI-NEXT:    fcvt s1, h10
2110; CHECK-GI-NEXT:    fcvt h0, s0
2111; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2112; CHECK-GI-NEXT:    fmov s0, s1
2113; CHECK-GI-NEXT:    bl exp2f
2114; CHECK-GI-NEXT:    ldp q3, q2, [sp] // 32-byte Folded Reload
2115; CHECK-GI-NEXT:    fcvt h0, s0
2116; CHECK-GI-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2117; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
2118; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
2119; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
2120; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
2121; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
2122; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
2123; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2124; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
2125; CHECK-GI-NEXT:    add sp, sp, #80
2126; CHECK-GI-NEXT:    ret
2127entry:
2128  %c = call <4 x half> @llvm.exp2.v4f16(<4 x half> %a)
2129  ret <4 x half> %c
2130}
2131
2132define <8 x half> @exp2_v8f16(<8 x half> %a) {
2133; CHECK-SD-LABEL: exp2_v8f16:
2134; CHECK-SD:       // %bb.0: // %entry
2135; CHECK-SD-NEXT:    sub sp, sp, #48
2136; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2137; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2138; CHECK-SD-NEXT:    .cfi_offset w30, -16
2139; CHECK-SD-NEXT:    mov h1, v0.h[1]
2140; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2141; CHECK-SD-NEXT:    fcvt s0, h1
2142; CHECK-SD-NEXT:    bl exp2f
2143; CHECK-SD-NEXT:    fcvt h0, s0
2144; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2145; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2146; CHECK-SD-NEXT:    fcvt s0, h0
2147; CHECK-SD-NEXT:    bl exp2f
2148; CHECK-SD-NEXT:    fcvt h0, s0
2149; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2150; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
2151; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2152; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2153; CHECK-SD-NEXT:    mov h0, v0.h[2]
2154; CHECK-SD-NEXT:    fcvt s0, h0
2155; CHECK-SD-NEXT:    bl exp2f
2156; CHECK-SD-NEXT:    fcvt h0, s0
2157; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2158; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
2159; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2160; CHECK-SD-NEXT:    mov h0, v0.h[3]
2161; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2162; CHECK-SD-NEXT:    fcvt s0, h0
2163; CHECK-SD-NEXT:    bl exp2f
2164; CHECK-SD-NEXT:    fcvt h0, s0
2165; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2166; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
2167; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2168; CHECK-SD-NEXT:    mov h0, v0.h[4]
2169; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2170; CHECK-SD-NEXT:    fcvt s0, h0
2171; CHECK-SD-NEXT:    bl exp2f
2172; CHECK-SD-NEXT:    fcvt h0, s0
2173; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2174; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
2175; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2176; CHECK-SD-NEXT:    mov h0, v0.h[5]
2177; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2178; CHECK-SD-NEXT:    fcvt s0, h0
2179; CHECK-SD-NEXT:    bl exp2f
2180; CHECK-SD-NEXT:    fcvt h0, s0
2181; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2182; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
2183; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2184; CHECK-SD-NEXT:    mov h0, v0.h[6]
2185; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2186; CHECK-SD-NEXT:    fcvt s0, h0
2187; CHECK-SD-NEXT:    bl exp2f
2188; CHECK-SD-NEXT:    fcvt h0, s0
2189; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2190; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
2191; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2192; CHECK-SD-NEXT:    mov h0, v0.h[7]
2193; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2194; CHECK-SD-NEXT:    fcvt s0, h0
2195; CHECK-SD-NEXT:    bl exp2f
2196; CHECK-SD-NEXT:    fcvt h1, s0
2197; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2198; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2199; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
2200; CHECK-SD-NEXT:    add sp, sp, #48
2201; CHECK-SD-NEXT:    ret
2202;
2203; CHECK-GI-LABEL: exp2_v8f16:
2204; CHECK-GI:       // %bb.0: // %entry
2205; CHECK-GI-NEXT:    sub sp, sp, #176
2206; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
2207; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
2208; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
2209; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
2210; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
2211; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
2212; CHECK-GI-NEXT:    .cfi_offset w30, -8
2213; CHECK-GI-NEXT:    .cfi_offset b8, -16
2214; CHECK-GI-NEXT:    .cfi_offset b9, -24
2215; CHECK-GI-NEXT:    .cfi_offset b10, -32
2216; CHECK-GI-NEXT:    .cfi_offset b11, -40
2217; CHECK-GI-NEXT:    .cfi_offset b12, -48
2218; CHECK-GI-NEXT:    .cfi_offset b13, -56
2219; CHECK-GI-NEXT:    .cfi_offset b14, -64
2220; CHECK-GI-NEXT:    mov h8, v0.h[1]
2221; CHECK-GI-NEXT:    mov h9, v0.h[2]
2222; CHECK-GI-NEXT:    mov h10, v0.h[3]
2223; CHECK-GI-NEXT:    mov h11, v0.h[4]
2224; CHECK-GI-NEXT:    mov h12, v0.h[5]
2225; CHECK-GI-NEXT:    mov h13, v0.h[6]
2226; CHECK-GI-NEXT:    mov h14, v0.h[7]
2227; CHECK-GI-NEXT:    fcvt s0, h0
2228; CHECK-GI-NEXT:    bl exp2f
2229; CHECK-GI-NEXT:    fcvt s1, h8
2230; CHECK-GI-NEXT:    fcvt h0, s0
2231; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
2232; CHECK-GI-NEXT:    fmov s0, s1
2233; CHECK-GI-NEXT:    bl exp2f
2234; CHECK-GI-NEXT:    fcvt s1, h9
2235; CHECK-GI-NEXT:    fcvt h0, s0
2236; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
2237; CHECK-GI-NEXT:    fmov s0, s1
2238; CHECK-GI-NEXT:    bl exp2f
2239; CHECK-GI-NEXT:    fcvt s1, h10
2240; CHECK-GI-NEXT:    fcvt h0, s0
2241; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
2242; CHECK-GI-NEXT:    fmov s0, s1
2243; CHECK-GI-NEXT:    bl exp2f
2244; CHECK-GI-NEXT:    fcvt s1, h11
2245; CHECK-GI-NEXT:    fcvt h0, s0
2246; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
2247; CHECK-GI-NEXT:    fmov s0, s1
2248; CHECK-GI-NEXT:    bl exp2f
2249; CHECK-GI-NEXT:    fcvt s1, h12
2250; CHECK-GI-NEXT:    fcvt h0, s0
2251; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2252; CHECK-GI-NEXT:    fmov s0, s1
2253; CHECK-GI-NEXT:    bl exp2f
2254; CHECK-GI-NEXT:    fcvt s1, h13
2255; CHECK-GI-NEXT:    fcvt h0, s0
2256; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2257; CHECK-GI-NEXT:    fmov s0, s1
2258; CHECK-GI-NEXT:    bl exp2f
2259; CHECK-GI-NEXT:    fcvt s1, h14
2260; CHECK-GI-NEXT:    fcvt h0, s0
2261; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2262; CHECK-GI-NEXT:    fmov s0, s1
2263; CHECK-GI-NEXT:    bl exp2f
2264; CHECK-GI-NEXT:    ldp q3, q2, [sp, #64] // 32-byte Folded Reload
2265; CHECK-GI-NEXT:    fcvt h0, s0
2266; CHECK-GI-NEXT:    ldr q1, [sp, #96] // 16-byte Folded Reload
2267; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
2268; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
2269; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
2270; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
2271; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
2272; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
2273; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
2274; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
2275; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
2276; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
2277; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
2278; CHECK-GI-NEXT:    mov v1.h[5], v3.h[0]
2279; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
2280; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
2281; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2282; CHECK-GI-NEXT:    add sp, sp, #176
2283; CHECK-GI-NEXT:    ret
2284entry:
2285  %c = call <8 x half> @llvm.exp2.v8f16(<8 x half> %a)
2286  ret <8 x half> %c
2287}
2288
2289define <16 x half> @exp2_v16f16(<16 x half> %a) {
2290; CHECK-SD-LABEL: exp2_v16f16:
2291; CHECK-SD:       // %bb.0: // %entry
2292; CHECK-SD-NEXT:    sub sp, sp, #64
2293; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
2294; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
2295; CHECK-SD-NEXT:    .cfi_offset w30, -16
2296; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
2297; CHECK-SD-NEXT:    mov h1, v0.h[1]
2298; CHECK-SD-NEXT:    fcvt s0, h1
2299; CHECK-SD-NEXT:    bl exp2f
2300; CHECK-SD-NEXT:    fcvt h0, s0
2301; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2302; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2303; CHECK-SD-NEXT:    fcvt s0, h0
2304; CHECK-SD-NEXT:    bl exp2f
2305; CHECK-SD-NEXT:    fcvt h0, s0
2306; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2307; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
2308; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2309; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2310; CHECK-SD-NEXT:    mov h0, v0.h[2]
2311; CHECK-SD-NEXT:    fcvt s0, h0
2312; CHECK-SD-NEXT:    bl exp2f
2313; CHECK-SD-NEXT:    fcvt h0, s0
2314; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2315; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
2316; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2317; CHECK-SD-NEXT:    mov h0, v0.h[3]
2318; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2319; CHECK-SD-NEXT:    fcvt s0, h0
2320; CHECK-SD-NEXT:    bl exp2f
2321; CHECK-SD-NEXT:    fcvt h0, s0
2322; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2323; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
2324; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2325; CHECK-SD-NEXT:    mov h0, v0.h[4]
2326; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2327; CHECK-SD-NEXT:    fcvt s0, h0
2328; CHECK-SD-NEXT:    bl exp2f
2329; CHECK-SD-NEXT:    fcvt h0, s0
2330; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2331; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
2332; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2333; CHECK-SD-NEXT:    mov h0, v0.h[5]
2334; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2335; CHECK-SD-NEXT:    fcvt s0, h0
2336; CHECK-SD-NEXT:    bl exp2f
2337; CHECK-SD-NEXT:    fcvt h0, s0
2338; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2339; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
2340; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2341; CHECK-SD-NEXT:    mov h0, v0.h[6]
2342; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2343; CHECK-SD-NEXT:    fcvt s0, h0
2344; CHECK-SD-NEXT:    bl exp2f
2345; CHECK-SD-NEXT:    fcvt h0, s0
2346; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2347; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
2348; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2349; CHECK-SD-NEXT:    mov h0, v0.h[7]
2350; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2351; CHECK-SD-NEXT:    fcvt s0, h0
2352; CHECK-SD-NEXT:    bl exp2f
2353; CHECK-SD-NEXT:    fcvt h0, s0
2354; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
2355; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
2356; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2357; CHECK-SD-NEXT:    mov h0, v0.h[1]
2358; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2359; CHECK-SD-NEXT:    fcvt s0, h0
2360; CHECK-SD-NEXT:    bl exp2f
2361; CHECK-SD-NEXT:    fcvt h0, s0
2362; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2363; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2364; CHECK-SD-NEXT:    fcvt s0, h0
2365; CHECK-SD-NEXT:    bl exp2f
2366; CHECK-SD-NEXT:    fcvt h0, s0
2367; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2368; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
2369; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2370; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2371; CHECK-SD-NEXT:    mov h0, v0.h[2]
2372; CHECK-SD-NEXT:    fcvt s0, h0
2373; CHECK-SD-NEXT:    bl exp2f
2374; CHECK-SD-NEXT:    fcvt h0, s0
2375; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2376; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
2377; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2378; CHECK-SD-NEXT:    mov h0, v0.h[3]
2379; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2380; CHECK-SD-NEXT:    fcvt s0, h0
2381; CHECK-SD-NEXT:    bl exp2f
2382; CHECK-SD-NEXT:    fcvt h0, s0
2383; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2384; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
2385; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2386; CHECK-SD-NEXT:    mov h0, v0.h[4]
2387; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2388; CHECK-SD-NEXT:    fcvt s0, h0
2389; CHECK-SD-NEXT:    bl exp2f
2390; CHECK-SD-NEXT:    fcvt h0, s0
2391; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2392; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
2393; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2394; CHECK-SD-NEXT:    mov h0, v0.h[5]
2395; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2396; CHECK-SD-NEXT:    fcvt s0, h0
2397; CHECK-SD-NEXT:    bl exp2f
2398; CHECK-SD-NEXT:    fcvt h0, s0
2399; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2400; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
2401; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2402; CHECK-SD-NEXT:    mov h0, v0.h[6]
2403; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2404; CHECK-SD-NEXT:    fcvt s0, h0
2405; CHECK-SD-NEXT:    bl exp2f
2406; CHECK-SD-NEXT:    fcvt h0, s0
2407; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2408; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
2409; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2410; CHECK-SD-NEXT:    mov h0, v0.h[7]
2411; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2412; CHECK-SD-NEXT:    fcvt s0, h0
2413; CHECK-SD-NEXT:    bl exp2f
2414; CHECK-SD-NEXT:    fmov s1, s0
2415; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
2416; CHECK-SD-NEXT:    fcvt h2, s1
2417; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
2418; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
2419; CHECK-SD-NEXT:    add sp, sp, #64
2420; CHECK-SD-NEXT:    ret
2421;
2422; CHECK-GI-LABEL: exp2_v16f16:
2423; CHECK-GI:       // %bb.0: // %entry
2424; CHECK-GI-NEXT:    sub sp, sp, #320
2425; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
2426; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
2427; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
2428; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
2429; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
2430; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
2431; CHECK-GI-NEXT:    .cfi_offset w30, -8
2432; CHECK-GI-NEXT:    .cfi_offset w29, -16
2433; CHECK-GI-NEXT:    .cfi_offset b8, -24
2434; CHECK-GI-NEXT:    .cfi_offset b9, -32
2435; CHECK-GI-NEXT:    .cfi_offset b10, -40
2436; CHECK-GI-NEXT:    .cfi_offset b11, -48
2437; CHECK-GI-NEXT:    .cfi_offset b12, -56
2438; CHECK-GI-NEXT:    .cfi_offset b13, -64
2439; CHECK-GI-NEXT:    .cfi_offset b14, -72
2440; CHECK-GI-NEXT:    .cfi_offset b15, -80
2441; CHECK-GI-NEXT:    mov v2.16b, v1.16b
2442; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
2443; CHECK-GI-NEXT:    mov h14, v1.h[1]
2444; CHECK-GI-NEXT:    mov h1, v1.h[2]
2445; CHECK-GI-NEXT:    mov h15, v0.h[1]
2446; CHECK-GI-NEXT:    mov h8, v0.h[2]
2447; CHECK-GI-NEXT:    mov h9, v0.h[3]
2448; CHECK-GI-NEXT:    mov h10, v0.h[4]
2449; CHECK-GI-NEXT:    mov h11, v0.h[5]
2450; CHECK-GI-NEXT:    mov h12, v0.h[6]
2451; CHECK-GI-NEXT:    mov h13, v0.h[7]
2452; CHECK-GI-NEXT:    fcvt s0, h0
2453; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
2454; CHECK-GI-NEXT:    mov h1, v2.h[3]
2455; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
2456; CHECK-GI-NEXT:    mov h1, v2.h[4]
2457; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
2458; CHECK-GI-NEXT:    mov h1, v2.h[5]
2459; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
2460; CHECK-GI-NEXT:    mov h1, v2.h[6]
2461; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
2462; CHECK-GI-NEXT:    mov h1, v2.h[7]
2463; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
2464; CHECK-GI-NEXT:    bl exp2f
2465; CHECK-GI-NEXT:    fcvt s1, h15
2466; CHECK-GI-NEXT:    fcvt h0, s0
2467; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
2468; CHECK-GI-NEXT:    fmov s0, s1
2469; CHECK-GI-NEXT:    bl exp2f
2470; CHECK-GI-NEXT:    fcvt s1, h8
2471; CHECK-GI-NEXT:    fcvt h0, s0
2472; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
2473; CHECK-GI-NEXT:    fmov s0, s1
2474; CHECK-GI-NEXT:    bl exp2f
2475; CHECK-GI-NEXT:    fcvt s1, h9
2476; CHECK-GI-NEXT:    fcvt h0, s0
2477; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
2478; CHECK-GI-NEXT:    fmov s0, s1
2479; CHECK-GI-NEXT:    bl exp2f
2480; CHECK-GI-NEXT:    fcvt s1, h10
2481; CHECK-GI-NEXT:    fcvt h0, s0
2482; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
2483; CHECK-GI-NEXT:    fmov s0, s1
2484; CHECK-GI-NEXT:    bl exp2f
2485; CHECK-GI-NEXT:    fcvt s1, h11
2486; CHECK-GI-NEXT:    fcvt h0, s0
2487; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
2488; CHECK-GI-NEXT:    fmov s0, s1
2489; CHECK-GI-NEXT:    bl exp2f
2490; CHECK-GI-NEXT:    fcvt s1, h12
2491; CHECK-GI-NEXT:    fcvt h0, s0
2492; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
2493; CHECK-GI-NEXT:    fmov s0, s1
2494; CHECK-GI-NEXT:    bl exp2f
2495; CHECK-GI-NEXT:    fcvt s1, h13
2496; CHECK-GI-NEXT:    fcvt h0, s0
2497; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
2498; CHECK-GI-NEXT:    fmov s0, s1
2499; CHECK-GI-NEXT:    bl exp2f
2500; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
2501; CHECK-GI-NEXT:    fcvt h0, s0
2502; CHECK-GI-NEXT:    fcvt s1, h1
2503; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
2504; CHECK-GI-NEXT:    fmov s0, s1
2505; CHECK-GI-NEXT:    bl exp2f
2506; CHECK-GI-NEXT:    fcvt s1, h14
2507; CHECK-GI-NEXT:    fcvt h0, s0
2508; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2509; CHECK-GI-NEXT:    fmov s0, s1
2510; CHECK-GI-NEXT:    bl exp2f
2511; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
2512; CHECK-GI-NEXT:    fcvt h0, s0
2513; CHECK-GI-NEXT:    fcvt s1, h1
2514; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2515; CHECK-GI-NEXT:    fmov s0, s1
2516; CHECK-GI-NEXT:    bl exp2f
2517; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
2518; CHECK-GI-NEXT:    fcvt h0, s0
2519; CHECK-GI-NEXT:    fcvt s1, h1
2520; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2521; CHECK-GI-NEXT:    fmov s0, s1
2522; CHECK-GI-NEXT:    bl exp2f
2523; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
2524; CHECK-GI-NEXT:    fcvt h0, s0
2525; CHECK-GI-NEXT:    fcvt s1, h1
2526; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
2527; CHECK-GI-NEXT:    fmov s0, s1
2528; CHECK-GI-NEXT:    bl exp2f
2529; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
2530; CHECK-GI-NEXT:    fcvt h0, s0
2531; CHECK-GI-NEXT:    fcvt s1, h1
2532; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
2533; CHECK-GI-NEXT:    fmov s0, s1
2534; CHECK-GI-NEXT:    bl exp2f
2535; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
2536; CHECK-GI-NEXT:    fcvt h0, s0
2537; CHECK-GI-NEXT:    fcvt s1, h1
2538; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
2539; CHECK-GI-NEXT:    fmov s0, s1
2540; CHECK-GI-NEXT:    bl exp2f
2541; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
2542; CHECK-GI-NEXT:    fcvt h0, s0
2543; CHECK-GI-NEXT:    fcvt s1, h1
2544; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
2545; CHECK-GI-NEXT:    fmov s0, s1
2546; CHECK-GI-NEXT:    bl exp2f
2547; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
2548; CHECK-GI-NEXT:    ldr q2, [sp, #112] // 16-byte Folded Reload
2549; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
2550; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
2551; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
2552; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
2553; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
2554; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
2555; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
2556; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
2557; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
2558; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
2559; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
2560; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
2561; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
2562; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
2563; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
2564; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
2565; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
2566; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
2567; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
2568; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
2569; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
2570; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
2571; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
2572; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
2573; CHECK-GI-NEXT:    fcvt h2, s0
2574; CHECK-GI-NEXT:    ldr q0, [sp, #128] // 16-byte Folded Reload
2575; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
2576; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
2577; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
2578; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
2579; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
2580; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
2581; CHECK-GI-NEXT:    mov v0.16b, v3.16b
2582; CHECK-GI-NEXT:    add sp, sp, #320
2583; CHECK-GI-NEXT:    ret
2584entry:
2585  %c = call <16 x half> @llvm.exp2.v16f16(<16 x half> %a)
2586  ret <16 x half> %c
2587}
2588
2589define <2 x fp128> @exp2_v2fp128(<2 x fp128> %a) {
2590; CHECK-LABEL: exp2_v2fp128:
2591; CHECK:       // %bb.0: // %entry
2592; CHECK-NEXT:    sub sp, sp, #48
2593; CHECK-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2594; CHECK-NEXT:    .cfi_def_cfa_offset 48
2595; CHECK-NEXT:    .cfi_offset w30, -16
2596; CHECK-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
2597; CHECK-NEXT:    bl exp2l
2598; CHECK-NEXT:    str q0, [sp] // 16-byte Folded Spill
2599; CHECK-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2600; CHECK-NEXT:    bl exp2l
2601; CHECK-NEXT:    mov v1.16b, v0.16b
2602; CHECK-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2603; CHECK-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2604; CHECK-NEXT:    add sp, sp, #48
2605; CHECK-NEXT:    ret
2606entry:
2607  %c = call <2 x fp128> @llvm.exp2.v2fp128(<2 x fp128> %a)
2608  ret <2 x fp128> %c
2609}
2610
2611define double @log_f64(double %a) {
2612; CHECK-LABEL: log_f64:
2613; CHECK:       // %bb.0: // %entry
2614; CHECK-NEXT:    b log
2615entry:
2616  %c = call double @llvm.log.f64(double %a)
2617  ret double %c
2618}
2619
2620define float @log_f32(float %a) {
2621; CHECK-LABEL: log_f32:
2622; CHECK:       // %bb.0: // %entry
2623; CHECK-NEXT:    b logf
2624entry:
2625  %c = call float @llvm.log.f32(float %a)
2626  ret float %c
2627}
2628
2629define half @log_f16(half %a) {
2630; CHECK-LABEL: log_f16:
2631; CHECK:       // %bb.0: // %entry
2632; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
2633; CHECK-NEXT:    .cfi_def_cfa_offset 16
2634; CHECK-NEXT:    .cfi_offset w30, -16
2635; CHECK-NEXT:    fcvt s0, h0
2636; CHECK-NEXT:    bl logf
2637; CHECK-NEXT:    fcvt h0, s0
2638; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
2639; CHECK-NEXT:    ret
2640entry:
2641  %c = call half @llvm.log.f16(half %a)
2642  ret half %c
2643}
2644
2645define fp128 @log_fp128(fp128 %a) {
2646; CHECK-LABEL: log_fp128:
2647; CHECK:       // %bb.0: // %entry
2648; CHECK-NEXT:    b logl
2649entry:
2650  %c = call fp128 @llvm.log.fp128(fp128 %a)
2651  ret fp128 %c
2652}
2653
2654define <1 x double> @log_v1f64(<1 x double> %a) {
2655; CHECK-LABEL: log_v1f64:
2656; CHECK:       // %bb.0: // %entry
2657; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
2658; CHECK-NEXT:    .cfi_def_cfa_offset 16
2659; CHECK-NEXT:    .cfi_offset w30, -16
2660; CHECK-NEXT:    bl log
2661; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
2662; CHECK-NEXT:    ret
2663entry:
2664  %c = call <1 x double> @llvm.log.v1f64(<1 x double> %a)
2665  ret <1 x double> %c
2666}
2667
2668define <2 x double> @log_v2f64(<2 x double> %a) {
2669; CHECK-SD-LABEL: log_v2f64:
2670; CHECK-SD:       // %bb.0: // %entry
2671; CHECK-SD-NEXT:    sub sp, sp, #48
2672; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2673; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2674; CHECK-SD-NEXT:    .cfi_offset w30, -16
2675; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2676; CHECK-SD-NEXT:    mov d0, v0.d[1]
2677; CHECK-SD-NEXT:    bl log
2678; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2679; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2680; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2681; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2682; CHECK-SD-NEXT:    bl log
2683; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2684; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2685; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2686; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
2687; CHECK-SD-NEXT:    add sp, sp, #48
2688; CHECK-SD-NEXT:    ret
2689;
2690; CHECK-GI-LABEL: log_v2f64:
2691; CHECK-GI:       // %bb.0: // %entry
2692; CHECK-GI-NEXT:    sub sp, sp, #32
2693; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
2694; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
2695; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
2696; CHECK-GI-NEXT:    .cfi_offset w30, -8
2697; CHECK-GI-NEXT:    .cfi_offset b8, -16
2698; CHECK-GI-NEXT:    mov d8, v0.d[1]
2699; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
2700; CHECK-GI-NEXT:    bl log
2701; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2702; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2703; CHECK-GI-NEXT:    fmov d0, d8
2704; CHECK-GI-NEXT:    bl log
2705; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2706; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2707; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
2708; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
2709; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
2710; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2711; CHECK-GI-NEXT:    add sp, sp, #32
2712; CHECK-GI-NEXT:    ret
2713entry:
2714  %c = call <2 x double> @llvm.log.v2f64(<2 x double> %a)
2715  ret <2 x double> %c
2716}
2717
2718define <3 x double> @log_v3f64(<3 x double> %a) {
2719; CHECK-SD-LABEL: log_v3f64:
2720; CHECK-SD:       // %bb.0: // %entry
2721; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
2722; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
2723; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
2724; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
2725; CHECK-SD-NEXT:    .cfi_offset w30, -8
2726; CHECK-SD-NEXT:    .cfi_offset b8, -16
2727; CHECK-SD-NEXT:    .cfi_offset b9, -24
2728; CHECK-SD-NEXT:    .cfi_offset b10, -32
2729; CHECK-SD-NEXT:    fmov d8, d2
2730; CHECK-SD-NEXT:    fmov d9, d1
2731; CHECK-SD-NEXT:    bl log
2732; CHECK-SD-NEXT:    fmov d10, d0
2733; CHECK-SD-NEXT:    fmov d0, d9
2734; CHECK-SD-NEXT:    bl log
2735; CHECK-SD-NEXT:    fmov d9, d0
2736; CHECK-SD-NEXT:    fmov d0, d8
2737; CHECK-SD-NEXT:    bl log
2738; CHECK-SD-NEXT:    fmov d1, d9
2739; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
2740; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
2741; CHECK-SD-NEXT:    fmov d2, d0
2742; CHECK-SD-NEXT:    fmov d0, d10
2743; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
2744; CHECK-SD-NEXT:    ret
2745;
2746; CHECK-GI-LABEL: log_v3f64:
2747; CHECK-GI:       // %bb.0: // %entry
2748; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
2749; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
2750; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
2751; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
2752; CHECK-GI-NEXT:    .cfi_offset w30, -8
2753; CHECK-GI-NEXT:    .cfi_offset b8, -16
2754; CHECK-GI-NEXT:    .cfi_offset b9, -24
2755; CHECK-GI-NEXT:    .cfi_offset b10, -32
2756; CHECK-GI-NEXT:    fmov d8, d1
2757; CHECK-GI-NEXT:    fmov d9, d2
2758; CHECK-GI-NEXT:    bl log
2759; CHECK-GI-NEXT:    fmov d10, d0
2760; CHECK-GI-NEXT:    fmov d0, d8
2761; CHECK-GI-NEXT:    bl log
2762; CHECK-GI-NEXT:    fmov d8, d0
2763; CHECK-GI-NEXT:    fmov d0, d9
2764; CHECK-GI-NEXT:    bl log
2765; CHECK-GI-NEXT:    fmov d1, d8
2766; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
2767; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
2768; CHECK-GI-NEXT:    fmov d2, d0
2769; CHECK-GI-NEXT:    fmov d0, d10
2770; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
2771; CHECK-GI-NEXT:    ret
2772entry:
2773  %c = call <3 x double> @llvm.log.v3f64(<3 x double> %a)
2774  ret <3 x double> %c
2775}
2776
2777define <4 x double> @log_v4f64(<4 x double> %a) {
2778; CHECK-SD-LABEL: log_v4f64:
2779; CHECK-SD:       // %bb.0: // %entry
2780; CHECK-SD-NEXT:    sub sp, sp, #64
2781; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
2782; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
2783; CHECK-SD-NEXT:    .cfi_offset w30, -16
2784; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2785; CHECK-SD-NEXT:    mov d0, v0.d[1]
2786; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
2787; CHECK-SD-NEXT:    bl log
2788; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2789; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2790; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2791; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2792; CHECK-SD-NEXT:    bl log
2793; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2794; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2795; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
2796; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2797; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
2798; CHECK-SD-NEXT:    mov d0, v0.d[1]
2799; CHECK-SD-NEXT:    bl log
2800; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2801; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2802; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
2803; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2804; CHECK-SD-NEXT:    bl log
2805; CHECK-SD-NEXT:    fmov d1, d0
2806; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
2807; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
2808; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
2809; CHECK-SD-NEXT:    add sp, sp, #64
2810; CHECK-SD-NEXT:    ret
2811;
2812; CHECK-GI-LABEL: log_v4f64:
2813; CHECK-GI:       // %bb.0: // %entry
2814; CHECK-GI-NEXT:    sub sp, sp, #80
2815; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
2816; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
2817; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
2818; CHECK-GI-NEXT:    .cfi_offset w30, -16
2819; CHECK-GI-NEXT:    .cfi_offset b8, -24
2820; CHECK-GI-NEXT:    .cfi_offset b9, -32
2821; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
2822; CHECK-GI-NEXT:    mov d8, v0.d[1]
2823; CHECK-GI-NEXT:    mov d9, v1.d[1]
2824; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
2825; CHECK-GI-NEXT:    bl log
2826; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2827; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
2828; CHECK-GI-NEXT:    fmov d0, d8
2829; CHECK-GI-NEXT:    bl log
2830; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2831; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2832; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2833; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
2834; CHECK-GI-NEXT:    bl log
2835; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2836; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2837; CHECK-GI-NEXT:    fmov d0, d9
2838; CHECK-GI-NEXT:    bl log
2839; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
2840; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2841; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
2842; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
2843; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
2844; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2845; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
2846; CHECK-GI-NEXT:    mov v0.16b, v2.16b
2847; CHECK-GI-NEXT:    add sp, sp, #80
2848; CHECK-GI-NEXT:    ret
2849entry:
2850  %c = call <4 x double> @llvm.log.v4f64(<4 x double> %a)
2851  ret <4 x double> %c
2852}
2853
2854define <2 x float> @log_v2f32(<2 x float> %a) {
2855; CHECK-SD-LABEL: log_v2f32:
2856; CHECK-SD:       // %bb.0: // %entry
2857; CHECK-SD-NEXT:    sub sp, sp, #48
2858; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2859; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2860; CHECK-SD-NEXT:    .cfi_offset w30, -16
2861; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
2862; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2863; CHECK-SD-NEXT:    mov s0, v0.s[1]
2864; CHECK-SD-NEXT:    bl logf
2865; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2866; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2867; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
2868; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
2869; CHECK-SD-NEXT:    bl logf
2870; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
2871; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2872; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2873; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
2874; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
2875; CHECK-SD-NEXT:    add sp, sp, #48
2876; CHECK-SD-NEXT:    ret
2877;
2878; CHECK-GI-LABEL: log_v2f32:
2879; CHECK-GI:       // %bb.0: // %entry
2880; CHECK-GI-NEXT:    sub sp, sp, #32
2881; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
2882; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
2883; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
2884; CHECK-GI-NEXT:    .cfi_offset w30, -8
2885; CHECK-GI-NEXT:    .cfi_offset b8, -16
2886; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
2887; CHECK-GI-NEXT:    mov s8, v0.s[1]
2888; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
2889; CHECK-GI-NEXT:    bl logf
2890; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2891; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2892; CHECK-GI-NEXT:    fmov s0, s8
2893; CHECK-GI-NEXT:    bl logf
2894; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2895; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2896; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
2897; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
2898; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
2899; CHECK-GI-NEXT:    fmov d0, d1
2900; CHECK-GI-NEXT:    add sp, sp, #32
2901; CHECK-GI-NEXT:    ret
2902entry:
2903  %c = call <2 x float> @llvm.log.v2f32(<2 x float> %a)
2904  ret <2 x float> %c
2905}
2906
2907define <3 x float> @log_v3f32(<3 x float> %a) {
2908; CHECK-SD-LABEL: log_v3f32:
2909; CHECK-SD:       // %bb.0: // %entry
2910; CHECK-SD-NEXT:    sub sp, sp, #48
2911; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2912; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2913; CHECK-SD-NEXT:    .cfi_offset w30, -16
2914; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2915; CHECK-SD-NEXT:    mov s0, v0.s[1]
2916; CHECK-SD-NEXT:    bl logf
2917; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2918; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2919; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2920; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
2921; CHECK-SD-NEXT:    bl logf
2922; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2923; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2924; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
2925; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2926; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2927; CHECK-SD-NEXT:    mov s0, v0.s[2]
2928; CHECK-SD-NEXT:    bl logf
2929; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2930; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2931; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
2932; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
2933; CHECK-SD-NEXT:    mov v0.16b, v1.16b
2934; CHECK-SD-NEXT:    add sp, sp, #48
2935; CHECK-SD-NEXT:    ret
2936;
2937; CHECK-GI-LABEL: log_v3f32:
2938; CHECK-GI:       // %bb.0: // %entry
2939; CHECK-GI-NEXT:    sub sp, sp, #64
2940; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
2941; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
2942; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
2943; CHECK-GI-NEXT:    .cfi_offset w30, -16
2944; CHECK-GI-NEXT:    .cfi_offset b8, -24
2945; CHECK-GI-NEXT:    .cfi_offset b9, -32
2946; CHECK-GI-NEXT:    mov s8, v0.s[1]
2947; CHECK-GI-NEXT:    mov s9, v0.s[2]
2948; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
2949; CHECK-GI-NEXT:    bl logf
2950; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2951; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2952; CHECK-GI-NEXT:    fmov s0, s8
2953; CHECK-GI-NEXT:    bl logf
2954; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2955; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
2956; CHECK-GI-NEXT:    fmov s0, s9
2957; CHECK-GI-NEXT:    bl logf
2958; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
2959; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
2960; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
2961; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
2962; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
2963; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
2964; CHECK-GI-NEXT:    mov v0.16b, v1.16b
2965; CHECK-GI-NEXT:    add sp, sp, #64
2966; CHECK-GI-NEXT:    ret
2967entry:
2968  %c = call <3 x float> @llvm.log.v3f32(<3 x float> %a)
2969  ret <3 x float> %c
2970}
2971
2972define <4 x float> @log_v4f32(<4 x float> %a) {
2973; CHECK-SD-LABEL: log_v4f32:
2974; CHECK-SD:       // %bb.0: // %entry
2975; CHECK-SD-NEXT:    sub sp, sp, #48
2976; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
2977; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
2978; CHECK-SD-NEXT:    .cfi_offset w30, -16
2979; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
2980; CHECK-SD-NEXT:    mov s0, v0.s[1]
2981; CHECK-SD-NEXT:    bl logf
2982; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2983; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2984; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2985; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
2986; CHECK-SD-NEXT:    bl logf
2987; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2988; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2989; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
2990; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
2991; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2992; CHECK-SD-NEXT:    mov s0, v0.s[2]
2993; CHECK-SD-NEXT:    bl logf
2994; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
2995; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
2996; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
2997; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
2998; CHECK-SD-NEXT:    mov s0, v0.s[3]
2999; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
3000; CHECK-SD-NEXT:    bl logf
3001; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3002; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3003; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3004; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
3005; CHECK-SD-NEXT:    mov v0.16b, v1.16b
3006; CHECK-SD-NEXT:    add sp, sp, #48
3007; CHECK-SD-NEXT:    ret
3008;
3009; CHECK-GI-LABEL: log_v4f32:
3010; CHECK-GI:       // %bb.0: // %entry
3011; CHECK-GI-NEXT:    sub sp, sp, #80
3012; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
3013; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
3014; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
3015; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
3016; CHECK-GI-NEXT:    .cfi_offset w30, -8
3017; CHECK-GI-NEXT:    .cfi_offset b8, -16
3018; CHECK-GI-NEXT:    .cfi_offset b9, -24
3019; CHECK-GI-NEXT:    .cfi_offset b10, -32
3020; CHECK-GI-NEXT:    mov s8, v0.s[1]
3021; CHECK-GI-NEXT:    mov s9, v0.s[2]
3022; CHECK-GI-NEXT:    mov s10, v0.s[3]
3023; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
3024; CHECK-GI-NEXT:    bl logf
3025; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3026; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3027; CHECK-GI-NEXT:    fmov s0, s8
3028; CHECK-GI-NEXT:    bl logf
3029; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3030; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3031; CHECK-GI-NEXT:    fmov s0, s9
3032; CHECK-GI-NEXT:    bl logf
3033; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3034; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3035; CHECK-GI-NEXT:    fmov s0, s10
3036; CHECK-GI-NEXT:    bl logf
3037; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
3038; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3039; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
3040; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
3041; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
3042; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
3043; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
3044; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
3045; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
3046; CHECK-GI-NEXT:    mov v0.16b, v1.16b
3047; CHECK-GI-NEXT:    add sp, sp, #80
3048; CHECK-GI-NEXT:    ret
3049entry:
3050  %c = call <4 x float> @llvm.log.v4f32(<4 x float> %a)
3051  ret <4 x float> %c
3052}
3053
3054define <8 x float> @log_v8f32(<8 x float> %a) {
3055; CHECK-SD-LABEL: log_v8f32:
3056; CHECK-SD:       // %bb.0: // %entry
3057; CHECK-SD-NEXT:    sub sp, sp, #64
3058; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
3059; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
3060; CHECK-SD-NEXT:    .cfi_offset w30, -16
3061; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
3062; CHECK-SD-NEXT:    mov s0, v0.s[1]
3063; CHECK-SD-NEXT:    bl logf
3064; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3065; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3066; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3067; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
3068; CHECK-SD-NEXT:    bl logf
3069; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3070; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3071; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
3072; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3073; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3074; CHECK-SD-NEXT:    mov s0, v0.s[2]
3075; CHECK-SD-NEXT:    bl logf
3076; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3077; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3078; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
3079; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3080; CHECK-SD-NEXT:    mov s0, v0.s[3]
3081; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3082; CHECK-SD-NEXT:    bl logf
3083; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3084; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3085; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
3086; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3087; CHECK-SD-NEXT:    mov s0, v0.s[1]
3088; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3089; CHECK-SD-NEXT:    bl logf
3090; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3091; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3092; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3093; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
3094; CHECK-SD-NEXT:    bl logf
3095; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3096; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3097; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
3098; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3099; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3100; CHECK-SD-NEXT:    mov s0, v0.s[2]
3101; CHECK-SD-NEXT:    bl logf
3102; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3103; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
3104; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
3105; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3106; CHECK-SD-NEXT:    mov s0, v0.s[3]
3107; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
3108; CHECK-SD-NEXT:    bl logf
3109; CHECK-SD-NEXT:    fmov s2, s0
3110; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3111; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
3112; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
3113; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
3114; CHECK-SD-NEXT:    add sp, sp, #64
3115; CHECK-SD-NEXT:    ret
3116;
3117; CHECK-GI-LABEL: log_v8f32:
3118; CHECK-GI:       // %bb.0: // %entry
3119; CHECK-GI-NEXT:    sub sp, sp, #176
3120; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
3121; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
3122; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
3123; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
3124; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
3125; CHECK-GI-NEXT:    .cfi_offset w30, -16
3126; CHECK-GI-NEXT:    .cfi_offset b8, -24
3127; CHECK-GI-NEXT:    .cfi_offset b9, -32
3128; CHECK-GI-NEXT:    .cfi_offset b10, -40
3129; CHECK-GI-NEXT:    .cfi_offset b11, -48
3130; CHECK-GI-NEXT:    .cfi_offset b12, -56
3131; CHECK-GI-NEXT:    .cfi_offset b13, -64
3132; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3133; CHECK-GI-NEXT:    mov s8, v0.s[1]
3134; CHECK-GI-NEXT:    mov s9, v0.s[2]
3135; CHECK-GI-NEXT:    mov s10, v0.s[3]
3136; CHECK-GI-NEXT:    mov s11, v1.s[1]
3137; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
3138; CHECK-GI-NEXT:    mov s12, v1.s[2]
3139; CHECK-GI-NEXT:    mov s13, v1.s[3]
3140; CHECK-GI-NEXT:    bl logf
3141; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3142; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
3143; CHECK-GI-NEXT:    fmov s0, s8
3144; CHECK-GI-NEXT:    bl logf
3145; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3146; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
3147; CHECK-GI-NEXT:    fmov s0, s9
3148; CHECK-GI-NEXT:    bl logf
3149; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3150; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
3151; CHECK-GI-NEXT:    fmov s0, s10
3152; CHECK-GI-NEXT:    bl logf
3153; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3154; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
3155; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
3156; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
3157; CHECK-GI-NEXT:    bl logf
3158; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3159; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3160; CHECK-GI-NEXT:    fmov s0, s11
3161; CHECK-GI-NEXT:    bl logf
3162; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3163; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3164; CHECK-GI-NEXT:    fmov s0, s12
3165; CHECK-GI-NEXT:    bl logf
3166; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3167; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3168; CHECK-GI-NEXT:    fmov s0, s13
3169; CHECK-GI-NEXT:    bl logf
3170; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
3171; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
3172; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
3173; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
3174; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
3175; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
3176; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
3177; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
3178; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
3179; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
3180; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
3181; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
3182; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
3183; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
3184; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
3185; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
3186; CHECK-GI-NEXT:    mov v2.16b, v1.16b
3187; CHECK-GI-NEXT:    mov v1.16b, v3.16b
3188; CHECK-GI-NEXT:    mov v0.16b, v2.16b
3189; CHECK-GI-NEXT:    add sp, sp, #176
3190; CHECK-GI-NEXT:    ret
3191entry:
3192  %c = call <8 x float> @llvm.log.v8f32(<8 x float> %a)
3193  ret <8 x float> %c
3194}
3195
3196define <7 x half> @log_v7f16(<7 x half> %a) {
3197; CHECK-SD-LABEL: log_v7f16:
3198; CHECK-SD:       // %bb.0: // %entry
3199; CHECK-SD-NEXT:    sub sp, sp, #48
3200; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
3201; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
3202; CHECK-SD-NEXT:    .cfi_offset w30, -16
3203; CHECK-SD-NEXT:    mov h1, v0.h[1]
3204; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3205; CHECK-SD-NEXT:    fcvt s0, h1
3206; CHECK-SD-NEXT:    bl logf
3207; CHECK-SD-NEXT:    fcvt h0, s0
3208; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3209; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3210; CHECK-SD-NEXT:    fcvt s0, h0
3211; CHECK-SD-NEXT:    bl logf
3212; CHECK-SD-NEXT:    fcvt h0, s0
3213; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3214; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
3215; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3216; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3217; CHECK-SD-NEXT:    mov h0, v0.h[2]
3218; CHECK-SD-NEXT:    fcvt s0, h0
3219; CHECK-SD-NEXT:    bl logf
3220; CHECK-SD-NEXT:    fcvt h0, s0
3221; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3222; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
3223; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3224; CHECK-SD-NEXT:    mov h0, v0.h[3]
3225; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3226; CHECK-SD-NEXT:    fcvt s0, h0
3227; CHECK-SD-NEXT:    bl logf
3228; CHECK-SD-NEXT:    fcvt h0, s0
3229; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3230; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
3231; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3232; CHECK-SD-NEXT:    mov h0, v0.h[4]
3233; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3234; CHECK-SD-NEXT:    fcvt s0, h0
3235; CHECK-SD-NEXT:    bl logf
3236; CHECK-SD-NEXT:    fcvt h0, s0
3237; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3238; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
3239; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3240; CHECK-SD-NEXT:    mov h0, v0.h[5]
3241; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3242; CHECK-SD-NEXT:    fcvt s0, h0
3243; CHECK-SD-NEXT:    bl logf
3244; CHECK-SD-NEXT:    fcvt h0, s0
3245; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3246; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
3247; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3248; CHECK-SD-NEXT:    mov h0, v0.h[6]
3249; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3250; CHECK-SD-NEXT:    fcvt s0, h0
3251; CHECK-SD-NEXT:    bl logf
3252; CHECK-SD-NEXT:    fcvt h0, s0
3253; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3254; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
3255; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3256; CHECK-SD-NEXT:    mov h0, v0.h[7]
3257; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3258; CHECK-SD-NEXT:    fcvt s0, h0
3259; CHECK-SD-NEXT:    bl logf
3260; CHECK-SD-NEXT:    fcvt h1, s0
3261; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3262; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3263; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
3264; CHECK-SD-NEXT:    add sp, sp, #48
3265; CHECK-SD-NEXT:    ret
3266;
3267; CHECK-GI-LABEL: log_v7f16:
3268; CHECK-GI:       // %bb.0: // %entry
3269; CHECK-GI-NEXT:    sub sp, sp, #160
3270; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
3271; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
3272; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
3273; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
3274; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
3275; CHECK-GI-NEXT:    .cfi_offset w30, -16
3276; CHECK-GI-NEXT:    .cfi_offset b8, -24
3277; CHECK-GI-NEXT:    .cfi_offset b9, -32
3278; CHECK-GI-NEXT:    .cfi_offset b10, -40
3279; CHECK-GI-NEXT:    .cfi_offset b11, -48
3280; CHECK-GI-NEXT:    .cfi_offset b12, -56
3281; CHECK-GI-NEXT:    .cfi_offset b13, -64
3282; CHECK-GI-NEXT:    mov h8, v0.h[1]
3283; CHECK-GI-NEXT:    mov h9, v0.h[2]
3284; CHECK-GI-NEXT:    mov h10, v0.h[3]
3285; CHECK-GI-NEXT:    mov h11, v0.h[4]
3286; CHECK-GI-NEXT:    mov h12, v0.h[5]
3287; CHECK-GI-NEXT:    mov h13, v0.h[6]
3288; CHECK-GI-NEXT:    fcvt s0, h0
3289; CHECK-GI-NEXT:    bl logf
3290; CHECK-GI-NEXT:    fcvt s1, h8
3291; CHECK-GI-NEXT:    fcvt h0, s0
3292; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
3293; CHECK-GI-NEXT:    fmov s0, s1
3294; CHECK-GI-NEXT:    bl logf
3295; CHECK-GI-NEXT:    fcvt s1, h9
3296; CHECK-GI-NEXT:    fcvt h0, s0
3297; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
3298; CHECK-GI-NEXT:    fmov s0, s1
3299; CHECK-GI-NEXT:    bl logf
3300; CHECK-GI-NEXT:    fcvt s1, h10
3301; CHECK-GI-NEXT:    fcvt h0, s0
3302; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
3303; CHECK-GI-NEXT:    fmov s0, s1
3304; CHECK-GI-NEXT:    bl logf
3305; CHECK-GI-NEXT:    fcvt s1, h11
3306; CHECK-GI-NEXT:    fcvt h0, s0
3307; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3308; CHECK-GI-NEXT:    fmov s0, s1
3309; CHECK-GI-NEXT:    bl logf
3310; CHECK-GI-NEXT:    fcvt s1, h12
3311; CHECK-GI-NEXT:    fcvt h0, s0
3312; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3313; CHECK-GI-NEXT:    fmov s0, s1
3314; CHECK-GI-NEXT:    bl logf
3315; CHECK-GI-NEXT:    fcvt s1, h13
3316; CHECK-GI-NEXT:    fcvt h0, s0
3317; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3318; CHECK-GI-NEXT:    fmov s0, s1
3319; CHECK-GI-NEXT:    bl logf
3320; CHECK-GI-NEXT:    ldp q3, q2, [sp, #48] // 32-byte Folded Reload
3321; CHECK-GI-NEXT:    fcvt h0, s0
3322; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
3323; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
3324; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
3325; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
3326; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
3327; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
3328; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
3329; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
3330; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
3331; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
3332; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
3333; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
3334; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
3335; CHECK-GI-NEXT:    mov v0.16b, v1.16b
3336; CHECK-GI-NEXT:    add sp, sp, #160
3337; CHECK-GI-NEXT:    ret
3338entry:
3339  %c = call <7 x half> @llvm.log.v7f16(<7 x half> %a)
3340  ret <7 x half> %c
3341}
3342
3343define <4 x half> @log_v4f16(<4 x half> %a) {
3344; CHECK-SD-LABEL: log_v4f16:
3345; CHECK-SD:       // %bb.0: // %entry
3346; CHECK-SD-NEXT:    sub sp, sp, #48
3347; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
3348; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
3349; CHECK-SD-NEXT:    .cfi_offset w30, -16
3350; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
3351; CHECK-SD-NEXT:    mov h1, v0.h[1]
3352; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3353; CHECK-SD-NEXT:    fcvt s0, h1
3354; CHECK-SD-NEXT:    bl logf
3355; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3356; CHECK-SD-NEXT:    fcvt h0, s0
3357; CHECK-SD-NEXT:    fcvt s1, h1
3358; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3359; CHECK-SD-NEXT:    fmov s0, s1
3360; CHECK-SD-NEXT:    bl logf
3361; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3362; CHECK-SD-NEXT:    fcvt h2, s0
3363; CHECK-SD-NEXT:    mov h1, v1.h[2]
3364; CHECK-SD-NEXT:    fcvt s0, h1
3365; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3366; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
3367; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
3368; CHECK-SD-NEXT:    bl logf
3369; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3370; CHECK-SD-NEXT:    fcvt h2, s0
3371; CHECK-SD-NEXT:    mov h1, v1.h[3]
3372; CHECK-SD-NEXT:    fcvt s0, h1
3373; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
3374; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
3375; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
3376; CHECK-SD-NEXT:    bl logf
3377; CHECK-SD-NEXT:    fcvt h1, s0
3378; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3379; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3380; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
3381; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
3382; CHECK-SD-NEXT:    add sp, sp, #48
3383; CHECK-SD-NEXT:    ret
3384;
3385; CHECK-GI-LABEL: log_v4f16:
3386; CHECK-GI:       // %bb.0: // %entry
3387; CHECK-GI-NEXT:    sub sp, sp, #80
3388; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
3389; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
3390; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
3391; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
3392; CHECK-GI-NEXT:    .cfi_offset w30, -8
3393; CHECK-GI-NEXT:    .cfi_offset b8, -16
3394; CHECK-GI-NEXT:    .cfi_offset b9, -24
3395; CHECK-GI-NEXT:    .cfi_offset b10, -32
3396; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
3397; CHECK-GI-NEXT:    mov h8, v0.h[1]
3398; CHECK-GI-NEXT:    mov h9, v0.h[2]
3399; CHECK-GI-NEXT:    mov h10, v0.h[3]
3400; CHECK-GI-NEXT:    fcvt s0, h0
3401; CHECK-GI-NEXT:    bl logf
3402; CHECK-GI-NEXT:    fcvt s1, h8
3403; CHECK-GI-NEXT:    fcvt h0, s0
3404; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3405; CHECK-GI-NEXT:    fmov s0, s1
3406; CHECK-GI-NEXT:    bl logf
3407; CHECK-GI-NEXT:    fcvt s1, h9
3408; CHECK-GI-NEXT:    fcvt h0, s0
3409; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3410; CHECK-GI-NEXT:    fmov s0, s1
3411; CHECK-GI-NEXT:    bl logf
3412; CHECK-GI-NEXT:    fcvt s1, h10
3413; CHECK-GI-NEXT:    fcvt h0, s0
3414; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3415; CHECK-GI-NEXT:    fmov s0, s1
3416; CHECK-GI-NEXT:    bl logf
3417; CHECK-GI-NEXT:    ldp q3, q2, [sp] // 32-byte Folded Reload
3418; CHECK-GI-NEXT:    fcvt h0, s0
3419; CHECK-GI-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3420; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
3421; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
3422; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
3423; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
3424; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
3425; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
3426; CHECK-GI-NEXT:    mov v0.16b, v1.16b
3427; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
3428; CHECK-GI-NEXT:    add sp, sp, #80
3429; CHECK-GI-NEXT:    ret
3430entry:
3431  %c = call <4 x half> @llvm.log.v4f16(<4 x half> %a)
3432  ret <4 x half> %c
3433}
3434
3435define <8 x half> @log_v8f16(<8 x half> %a) {
3436; CHECK-SD-LABEL: log_v8f16:
3437; CHECK-SD:       // %bb.0: // %entry
3438; CHECK-SD-NEXT:    sub sp, sp, #48
3439; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
3440; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
3441; CHECK-SD-NEXT:    .cfi_offset w30, -16
3442; CHECK-SD-NEXT:    mov h1, v0.h[1]
3443; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3444; CHECK-SD-NEXT:    fcvt s0, h1
3445; CHECK-SD-NEXT:    bl logf
3446; CHECK-SD-NEXT:    fcvt h0, s0
3447; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3448; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3449; CHECK-SD-NEXT:    fcvt s0, h0
3450; CHECK-SD-NEXT:    bl logf
3451; CHECK-SD-NEXT:    fcvt h0, s0
3452; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3453; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
3454; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3455; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3456; CHECK-SD-NEXT:    mov h0, v0.h[2]
3457; CHECK-SD-NEXT:    fcvt s0, h0
3458; CHECK-SD-NEXT:    bl logf
3459; CHECK-SD-NEXT:    fcvt h0, s0
3460; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3461; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
3462; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3463; CHECK-SD-NEXT:    mov h0, v0.h[3]
3464; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3465; CHECK-SD-NEXT:    fcvt s0, h0
3466; CHECK-SD-NEXT:    bl logf
3467; CHECK-SD-NEXT:    fcvt h0, s0
3468; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3469; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
3470; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3471; CHECK-SD-NEXT:    mov h0, v0.h[4]
3472; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3473; CHECK-SD-NEXT:    fcvt s0, h0
3474; CHECK-SD-NEXT:    bl logf
3475; CHECK-SD-NEXT:    fcvt h0, s0
3476; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3477; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
3478; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3479; CHECK-SD-NEXT:    mov h0, v0.h[5]
3480; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3481; CHECK-SD-NEXT:    fcvt s0, h0
3482; CHECK-SD-NEXT:    bl logf
3483; CHECK-SD-NEXT:    fcvt h0, s0
3484; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3485; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
3486; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3487; CHECK-SD-NEXT:    mov h0, v0.h[6]
3488; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3489; CHECK-SD-NEXT:    fcvt s0, h0
3490; CHECK-SD-NEXT:    bl logf
3491; CHECK-SD-NEXT:    fcvt h0, s0
3492; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3493; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
3494; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3495; CHECK-SD-NEXT:    mov h0, v0.h[7]
3496; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3497; CHECK-SD-NEXT:    fcvt s0, h0
3498; CHECK-SD-NEXT:    bl logf
3499; CHECK-SD-NEXT:    fcvt h1, s0
3500; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3501; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3502; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
3503; CHECK-SD-NEXT:    add sp, sp, #48
3504; CHECK-SD-NEXT:    ret
3505;
3506; CHECK-GI-LABEL: log_v8f16:
3507; CHECK-GI:       // %bb.0: // %entry
3508; CHECK-GI-NEXT:    sub sp, sp, #176
3509; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
3510; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
3511; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
3512; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
3513; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
3514; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
3515; CHECK-GI-NEXT:    .cfi_offset w30, -8
3516; CHECK-GI-NEXT:    .cfi_offset b8, -16
3517; CHECK-GI-NEXT:    .cfi_offset b9, -24
3518; CHECK-GI-NEXT:    .cfi_offset b10, -32
3519; CHECK-GI-NEXT:    .cfi_offset b11, -40
3520; CHECK-GI-NEXT:    .cfi_offset b12, -48
3521; CHECK-GI-NEXT:    .cfi_offset b13, -56
3522; CHECK-GI-NEXT:    .cfi_offset b14, -64
3523; CHECK-GI-NEXT:    mov h8, v0.h[1]
3524; CHECK-GI-NEXT:    mov h9, v0.h[2]
3525; CHECK-GI-NEXT:    mov h10, v0.h[3]
3526; CHECK-GI-NEXT:    mov h11, v0.h[4]
3527; CHECK-GI-NEXT:    mov h12, v0.h[5]
3528; CHECK-GI-NEXT:    mov h13, v0.h[6]
3529; CHECK-GI-NEXT:    mov h14, v0.h[7]
3530; CHECK-GI-NEXT:    fcvt s0, h0
3531; CHECK-GI-NEXT:    bl logf
3532; CHECK-GI-NEXT:    fcvt s1, h8
3533; CHECK-GI-NEXT:    fcvt h0, s0
3534; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
3535; CHECK-GI-NEXT:    fmov s0, s1
3536; CHECK-GI-NEXT:    bl logf
3537; CHECK-GI-NEXT:    fcvt s1, h9
3538; CHECK-GI-NEXT:    fcvt h0, s0
3539; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
3540; CHECK-GI-NEXT:    fmov s0, s1
3541; CHECK-GI-NEXT:    bl logf
3542; CHECK-GI-NEXT:    fcvt s1, h10
3543; CHECK-GI-NEXT:    fcvt h0, s0
3544; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
3545; CHECK-GI-NEXT:    fmov s0, s1
3546; CHECK-GI-NEXT:    bl logf
3547; CHECK-GI-NEXT:    fcvt s1, h11
3548; CHECK-GI-NEXT:    fcvt h0, s0
3549; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
3550; CHECK-GI-NEXT:    fmov s0, s1
3551; CHECK-GI-NEXT:    bl logf
3552; CHECK-GI-NEXT:    fcvt s1, h12
3553; CHECK-GI-NEXT:    fcvt h0, s0
3554; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3555; CHECK-GI-NEXT:    fmov s0, s1
3556; CHECK-GI-NEXT:    bl logf
3557; CHECK-GI-NEXT:    fcvt s1, h13
3558; CHECK-GI-NEXT:    fcvt h0, s0
3559; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3560; CHECK-GI-NEXT:    fmov s0, s1
3561; CHECK-GI-NEXT:    bl logf
3562; CHECK-GI-NEXT:    fcvt s1, h14
3563; CHECK-GI-NEXT:    fcvt h0, s0
3564; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3565; CHECK-GI-NEXT:    fmov s0, s1
3566; CHECK-GI-NEXT:    bl logf
3567; CHECK-GI-NEXT:    ldp q3, q2, [sp, #64] // 32-byte Folded Reload
3568; CHECK-GI-NEXT:    fcvt h0, s0
3569; CHECK-GI-NEXT:    ldr q1, [sp, #96] // 16-byte Folded Reload
3570; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
3571; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
3572; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
3573; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
3574; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
3575; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
3576; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
3577; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
3578; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
3579; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
3580; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
3581; CHECK-GI-NEXT:    mov v1.h[5], v3.h[0]
3582; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
3583; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
3584; CHECK-GI-NEXT:    mov v0.16b, v1.16b
3585; CHECK-GI-NEXT:    add sp, sp, #176
3586; CHECK-GI-NEXT:    ret
3587entry:
3588  %c = call <8 x half> @llvm.log.v8f16(<8 x half> %a)
3589  ret <8 x half> %c
3590}
3591
3592define <16 x half> @log_v16f16(<16 x half> %a) {
3593; CHECK-SD-LABEL: log_v16f16:
3594; CHECK-SD:       // %bb.0: // %entry
3595; CHECK-SD-NEXT:    sub sp, sp, #64
3596; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
3597; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
3598; CHECK-SD-NEXT:    .cfi_offset w30, -16
3599; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
3600; CHECK-SD-NEXT:    mov h1, v0.h[1]
3601; CHECK-SD-NEXT:    fcvt s0, h1
3602; CHECK-SD-NEXT:    bl logf
3603; CHECK-SD-NEXT:    fcvt h0, s0
3604; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3605; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3606; CHECK-SD-NEXT:    fcvt s0, h0
3607; CHECK-SD-NEXT:    bl logf
3608; CHECK-SD-NEXT:    fcvt h0, s0
3609; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3610; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
3611; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3612; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3613; CHECK-SD-NEXT:    mov h0, v0.h[2]
3614; CHECK-SD-NEXT:    fcvt s0, h0
3615; CHECK-SD-NEXT:    bl logf
3616; CHECK-SD-NEXT:    fcvt h0, s0
3617; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3618; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
3619; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3620; CHECK-SD-NEXT:    mov h0, v0.h[3]
3621; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3622; CHECK-SD-NEXT:    fcvt s0, h0
3623; CHECK-SD-NEXT:    bl logf
3624; CHECK-SD-NEXT:    fcvt h0, s0
3625; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3626; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
3627; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3628; CHECK-SD-NEXT:    mov h0, v0.h[4]
3629; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3630; CHECK-SD-NEXT:    fcvt s0, h0
3631; CHECK-SD-NEXT:    bl logf
3632; CHECK-SD-NEXT:    fcvt h0, s0
3633; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3634; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
3635; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3636; CHECK-SD-NEXT:    mov h0, v0.h[5]
3637; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3638; CHECK-SD-NEXT:    fcvt s0, h0
3639; CHECK-SD-NEXT:    bl logf
3640; CHECK-SD-NEXT:    fcvt h0, s0
3641; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3642; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
3643; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3644; CHECK-SD-NEXT:    mov h0, v0.h[6]
3645; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3646; CHECK-SD-NEXT:    fcvt s0, h0
3647; CHECK-SD-NEXT:    bl logf
3648; CHECK-SD-NEXT:    fcvt h0, s0
3649; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3650; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
3651; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3652; CHECK-SD-NEXT:    mov h0, v0.h[7]
3653; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3654; CHECK-SD-NEXT:    fcvt s0, h0
3655; CHECK-SD-NEXT:    bl logf
3656; CHECK-SD-NEXT:    fcvt h0, s0
3657; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
3658; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
3659; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3660; CHECK-SD-NEXT:    mov h0, v0.h[1]
3661; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
3662; CHECK-SD-NEXT:    fcvt s0, h0
3663; CHECK-SD-NEXT:    bl logf
3664; CHECK-SD-NEXT:    fcvt h0, s0
3665; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3666; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3667; CHECK-SD-NEXT:    fcvt s0, h0
3668; CHECK-SD-NEXT:    bl logf
3669; CHECK-SD-NEXT:    fcvt h0, s0
3670; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3671; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
3672; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3673; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3674; CHECK-SD-NEXT:    mov h0, v0.h[2]
3675; CHECK-SD-NEXT:    fcvt s0, h0
3676; CHECK-SD-NEXT:    bl logf
3677; CHECK-SD-NEXT:    fcvt h0, s0
3678; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3679; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
3680; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3681; CHECK-SD-NEXT:    mov h0, v0.h[3]
3682; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3683; CHECK-SD-NEXT:    fcvt s0, h0
3684; CHECK-SD-NEXT:    bl logf
3685; CHECK-SD-NEXT:    fcvt h0, s0
3686; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3687; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
3688; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3689; CHECK-SD-NEXT:    mov h0, v0.h[4]
3690; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3691; CHECK-SD-NEXT:    fcvt s0, h0
3692; CHECK-SD-NEXT:    bl logf
3693; CHECK-SD-NEXT:    fcvt h0, s0
3694; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3695; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
3696; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3697; CHECK-SD-NEXT:    mov h0, v0.h[5]
3698; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3699; CHECK-SD-NEXT:    fcvt s0, h0
3700; CHECK-SD-NEXT:    bl logf
3701; CHECK-SD-NEXT:    fcvt h0, s0
3702; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3703; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
3704; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3705; CHECK-SD-NEXT:    mov h0, v0.h[6]
3706; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3707; CHECK-SD-NEXT:    fcvt s0, h0
3708; CHECK-SD-NEXT:    bl logf
3709; CHECK-SD-NEXT:    fcvt h0, s0
3710; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3711; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
3712; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3713; CHECK-SD-NEXT:    mov h0, v0.h[7]
3714; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3715; CHECK-SD-NEXT:    fcvt s0, h0
3716; CHECK-SD-NEXT:    bl logf
3717; CHECK-SD-NEXT:    fmov s1, s0
3718; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
3719; CHECK-SD-NEXT:    fcvt h2, s1
3720; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
3721; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
3722; CHECK-SD-NEXT:    add sp, sp, #64
3723; CHECK-SD-NEXT:    ret
3724;
3725; CHECK-GI-LABEL: log_v16f16:
3726; CHECK-GI:       // %bb.0: // %entry
3727; CHECK-GI-NEXT:    sub sp, sp, #320
3728; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
3729; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
3730; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
3731; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
3732; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
3733; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
3734; CHECK-GI-NEXT:    .cfi_offset w30, -8
3735; CHECK-GI-NEXT:    .cfi_offset w29, -16
3736; CHECK-GI-NEXT:    .cfi_offset b8, -24
3737; CHECK-GI-NEXT:    .cfi_offset b9, -32
3738; CHECK-GI-NEXT:    .cfi_offset b10, -40
3739; CHECK-GI-NEXT:    .cfi_offset b11, -48
3740; CHECK-GI-NEXT:    .cfi_offset b12, -56
3741; CHECK-GI-NEXT:    .cfi_offset b13, -64
3742; CHECK-GI-NEXT:    .cfi_offset b14, -72
3743; CHECK-GI-NEXT:    .cfi_offset b15, -80
3744; CHECK-GI-NEXT:    mov v2.16b, v1.16b
3745; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
3746; CHECK-GI-NEXT:    mov h14, v1.h[1]
3747; CHECK-GI-NEXT:    mov h1, v1.h[2]
3748; CHECK-GI-NEXT:    mov h15, v0.h[1]
3749; CHECK-GI-NEXT:    mov h8, v0.h[2]
3750; CHECK-GI-NEXT:    mov h9, v0.h[3]
3751; CHECK-GI-NEXT:    mov h10, v0.h[4]
3752; CHECK-GI-NEXT:    mov h11, v0.h[5]
3753; CHECK-GI-NEXT:    mov h12, v0.h[6]
3754; CHECK-GI-NEXT:    mov h13, v0.h[7]
3755; CHECK-GI-NEXT:    fcvt s0, h0
3756; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
3757; CHECK-GI-NEXT:    mov h1, v2.h[3]
3758; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
3759; CHECK-GI-NEXT:    mov h1, v2.h[4]
3760; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
3761; CHECK-GI-NEXT:    mov h1, v2.h[5]
3762; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
3763; CHECK-GI-NEXT:    mov h1, v2.h[6]
3764; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
3765; CHECK-GI-NEXT:    mov h1, v2.h[7]
3766; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
3767; CHECK-GI-NEXT:    bl logf
3768; CHECK-GI-NEXT:    fcvt s1, h15
3769; CHECK-GI-NEXT:    fcvt h0, s0
3770; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
3771; CHECK-GI-NEXT:    fmov s0, s1
3772; CHECK-GI-NEXT:    bl logf
3773; CHECK-GI-NEXT:    fcvt s1, h8
3774; CHECK-GI-NEXT:    fcvt h0, s0
3775; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
3776; CHECK-GI-NEXT:    fmov s0, s1
3777; CHECK-GI-NEXT:    bl logf
3778; CHECK-GI-NEXT:    fcvt s1, h9
3779; CHECK-GI-NEXT:    fcvt h0, s0
3780; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
3781; CHECK-GI-NEXT:    fmov s0, s1
3782; CHECK-GI-NEXT:    bl logf
3783; CHECK-GI-NEXT:    fcvt s1, h10
3784; CHECK-GI-NEXT:    fcvt h0, s0
3785; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
3786; CHECK-GI-NEXT:    fmov s0, s1
3787; CHECK-GI-NEXT:    bl logf
3788; CHECK-GI-NEXT:    fcvt s1, h11
3789; CHECK-GI-NEXT:    fcvt h0, s0
3790; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
3791; CHECK-GI-NEXT:    fmov s0, s1
3792; CHECK-GI-NEXT:    bl logf
3793; CHECK-GI-NEXT:    fcvt s1, h12
3794; CHECK-GI-NEXT:    fcvt h0, s0
3795; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
3796; CHECK-GI-NEXT:    fmov s0, s1
3797; CHECK-GI-NEXT:    bl logf
3798; CHECK-GI-NEXT:    fcvt s1, h13
3799; CHECK-GI-NEXT:    fcvt h0, s0
3800; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
3801; CHECK-GI-NEXT:    fmov s0, s1
3802; CHECK-GI-NEXT:    bl logf
3803; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
3804; CHECK-GI-NEXT:    fcvt h0, s0
3805; CHECK-GI-NEXT:    fcvt s1, h1
3806; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
3807; CHECK-GI-NEXT:    fmov s0, s1
3808; CHECK-GI-NEXT:    bl logf
3809; CHECK-GI-NEXT:    fcvt s1, h14
3810; CHECK-GI-NEXT:    fcvt h0, s0
3811; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
3812; CHECK-GI-NEXT:    fmov s0, s1
3813; CHECK-GI-NEXT:    bl logf
3814; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
3815; CHECK-GI-NEXT:    fcvt h0, s0
3816; CHECK-GI-NEXT:    fcvt s1, h1
3817; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3818; CHECK-GI-NEXT:    fmov s0, s1
3819; CHECK-GI-NEXT:    bl logf
3820; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
3821; CHECK-GI-NEXT:    fcvt h0, s0
3822; CHECK-GI-NEXT:    fcvt s1, h1
3823; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
3824; CHECK-GI-NEXT:    fmov s0, s1
3825; CHECK-GI-NEXT:    bl logf
3826; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
3827; CHECK-GI-NEXT:    fcvt h0, s0
3828; CHECK-GI-NEXT:    fcvt s1, h1
3829; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
3830; CHECK-GI-NEXT:    fmov s0, s1
3831; CHECK-GI-NEXT:    bl logf
3832; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
3833; CHECK-GI-NEXT:    fcvt h0, s0
3834; CHECK-GI-NEXT:    fcvt s1, h1
3835; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
3836; CHECK-GI-NEXT:    fmov s0, s1
3837; CHECK-GI-NEXT:    bl logf
3838; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
3839; CHECK-GI-NEXT:    fcvt h0, s0
3840; CHECK-GI-NEXT:    fcvt s1, h1
3841; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
3842; CHECK-GI-NEXT:    fmov s0, s1
3843; CHECK-GI-NEXT:    bl logf
3844; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
3845; CHECK-GI-NEXT:    fcvt h0, s0
3846; CHECK-GI-NEXT:    fcvt s1, h1
3847; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
3848; CHECK-GI-NEXT:    fmov s0, s1
3849; CHECK-GI-NEXT:    bl logf
3850; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
3851; CHECK-GI-NEXT:    ldr q2, [sp, #112] // 16-byte Folded Reload
3852; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
3853; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
3854; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
3855; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
3856; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
3857; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
3858; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
3859; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
3860; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
3861; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
3862; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
3863; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
3864; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
3865; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
3866; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
3867; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
3868; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
3869; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
3870; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
3871; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
3872; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
3873; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
3874; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
3875; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
3876; CHECK-GI-NEXT:    fcvt h2, s0
3877; CHECK-GI-NEXT:    ldr q0, [sp, #128] // 16-byte Folded Reload
3878; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
3879; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
3880; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
3881; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
3882; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
3883; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
3884; CHECK-GI-NEXT:    mov v0.16b, v3.16b
3885; CHECK-GI-NEXT:    add sp, sp, #320
3886; CHECK-GI-NEXT:    ret
3887entry:
3888  %c = call <16 x half> @llvm.log.v16f16(<16 x half> %a)
3889  ret <16 x half> %c
3890}
3891
3892define <2 x fp128> @log_v2fp128(<2 x fp128> %a) {
3893; CHECK-LABEL: log_v2fp128:
3894; CHECK:       // %bb.0: // %entry
3895; CHECK-NEXT:    sub sp, sp, #48
3896; CHECK-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
3897; CHECK-NEXT:    .cfi_def_cfa_offset 48
3898; CHECK-NEXT:    .cfi_offset w30, -16
3899; CHECK-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
3900; CHECK-NEXT:    bl logl
3901; CHECK-NEXT:    str q0, [sp] // 16-byte Folded Spill
3902; CHECK-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
3903; CHECK-NEXT:    bl logl
3904; CHECK-NEXT:    mov v1.16b, v0.16b
3905; CHECK-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3906; CHECK-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3907; CHECK-NEXT:    add sp, sp, #48
3908; CHECK-NEXT:    ret
3909entry:
3910  %c = call <2 x fp128> @llvm.log.v2fp128(<2 x fp128> %a)
3911  ret <2 x fp128> %c
3912}
3913
3914define double @log2_f64(double %a) {
3915; CHECK-LABEL: log2_f64:
3916; CHECK:       // %bb.0: // %entry
3917; CHECK-NEXT:    b log2
3918entry:
3919  %c = call double @llvm.log2.f64(double %a)
3920  ret double %c
3921}
3922
3923define float @log2_f32(float %a) {
3924; CHECK-LABEL: log2_f32:
3925; CHECK:       // %bb.0: // %entry
3926; CHECK-NEXT:    b log2f
3927entry:
3928  %c = call float @llvm.log2.f32(float %a)
3929  ret float %c
3930}
3931
3932define half @log2_f16(half %a) {
3933; CHECK-LABEL: log2_f16:
3934; CHECK:       // %bb.0: // %entry
3935; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
3936; CHECK-NEXT:    .cfi_def_cfa_offset 16
3937; CHECK-NEXT:    .cfi_offset w30, -16
3938; CHECK-NEXT:    fcvt s0, h0
3939; CHECK-NEXT:    bl log2f
3940; CHECK-NEXT:    fcvt h0, s0
3941; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
3942; CHECK-NEXT:    ret
3943entry:
3944  %c = call half @llvm.log2.f16(half %a)
3945  ret half %c
3946}
3947
3948define fp128 @log2_fp128(fp128 %a) {
3949; CHECK-LABEL: log2_fp128:
3950; CHECK:       // %bb.0: // %entry
3951; CHECK-NEXT:    b log2l
3952entry:
3953  %c = call fp128 @llvm.log2.fp128(fp128 %a)
3954  ret fp128 %c
3955}
3956
3957define <1 x double> @log2_v1f64(<1 x double> %a) {
3958; CHECK-LABEL: log2_v1f64:
3959; CHECK:       // %bb.0: // %entry
3960; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
3961; CHECK-NEXT:    .cfi_def_cfa_offset 16
3962; CHECK-NEXT:    .cfi_offset w30, -16
3963; CHECK-NEXT:    bl log2
3964; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
3965; CHECK-NEXT:    ret
3966entry:
3967  %c = call <1 x double> @llvm.log2.v1f64(<1 x double> %a)
3968  ret <1 x double> %c
3969}
3970
3971define <2 x double> @log2_v2f64(<2 x double> %a) {
3972; CHECK-SD-LABEL: log2_v2f64:
3973; CHECK-SD:       // %bb.0: // %entry
3974; CHECK-SD-NEXT:    sub sp, sp, #48
3975; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
3976; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
3977; CHECK-SD-NEXT:    .cfi_offset w30, -16
3978; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
3979; CHECK-SD-NEXT:    mov d0, v0.d[1]
3980; CHECK-SD-NEXT:    bl log2
3981; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
3982; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
3983; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
3984; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
3985; CHECK-SD-NEXT:    bl log2
3986; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
3987; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
3988; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
3989; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
3990; CHECK-SD-NEXT:    add sp, sp, #48
3991; CHECK-SD-NEXT:    ret
3992;
3993; CHECK-GI-LABEL: log2_v2f64:
3994; CHECK-GI:       // %bb.0: // %entry
3995; CHECK-GI-NEXT:    sub sp, sp, #32
3996; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
3997; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
3998; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
3999; CHECK-GI-NEXT:    .cfi_offset w30, -8
4000; CHECK-GI-NEXT:    .cfi_offset b8, -16
4001; CHECK-GI-NEXT:    mov d8, v0.d[1]
4002; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
4003; CHECK-GI-NEXT:    bl log2
4004; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4005; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4006; CHECK-GI-NEXT:    fmov d0, d8
4007; CHECK-GI-NEXT:    bl log2
4008; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4009; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4010; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
4011; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
4012; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
4013; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4014; CHECK-GI-NEXT:    add sp, sp, #32
4015; CHECK-GI-NEXT:    ret
4016entry:
4017  %c = call <2 x double> @llvm.log2.v2f64(<2 x double> %a)
4018  ret <2 x double> %c
4019}
4020
4021define <3 x double> @log2_v3f64(<3 x double> %a) {
4022; CHECK-SD-LABEL: log2_v3f64:
4023; CHECK-SD:       // %bb.0: // %entry
4024; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
4025; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
4026; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
4027; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
4028; CHECK-SD-NEXT:    .cfi_offset w30, -8
4029; CHECK-SD-NEXT:    .cfi_offset b8, -16
4030; CHECK-SD-NEXT:    .cfi_offset b9, -24
4031; CHECK-SD-NEXT:    .cfi_offset b10, -32
4032; CHECK-SD-NEXT:    fmov d8, d2
4033; CHECK-SD-NEXT:    fmov d9, d1
4034; CHECK-SD-NEXT:    bl log2
4035; CHECK-SD-NEXT:    fmov d10, d0
4036; CHECK-SD-NEXT:    fmov d0, d9
4037; CHECK-SD-NEXT:    bl log2
4038; CHECK-SD-NEXT:    fmov d9, d0
4039; CHECK-SD-NEXT:    fmov d0, d8
4040; CHECK-SD-NEXT:    bl log2
4041; CHECK-SD-NEXT:    fmov d1, d9
4042; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
4043; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
4044; CHECK-SD-NEXT:    fmov d2, d0
4045; CHECK-SD-NEXT:    fmov d0, d10
4046; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
4047; CHECK-SD-NEXT:    ret
4048;
4049; CHECK-GI-LABEL: log2_v3f64:
4050; CHECK-GI:       // %bb.0: // %entry
4051; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
4052; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
4053; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
4054; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
4055; CHECK-GI-NEXT:    .cfi_offset w30, -8
4056; CHECK-GI-NEXT:    .cfi_offset b8, -16
4057; CHECK-GI-NEXT:    .cfi_offset b9, -24
4058; CHECK-GI-NEXT:    .cfi_offset b10, -32
4059; CHECK-GI-NEXT:    fmov d8, d1
4060; CHECK-GI-NEXT:    fmov d9, d2
4061; CHECK-GI-NEXT:    bl log2
4062; CHECK-GI-NEXT:    fmov d10, d0
4063; CHECK-GI-NEXT:    fmov d0, d8
4064; CHECK-GI-NEXT:    bl log2
4065; CHECK-GI-NEXT:    fmov d8, d0
4066; CHECK-GI-NEXT:    fmov d0, d9
4067; CHECK-GI-NEXT:    bl log2
4068; CHECK-GI-NEXT:    fmov d1, d8
4069; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
4070; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
4071; CHECK-GI-NEXT:    fmov d2, d0
4072; CHECK-GI-NEXT:    fmov d0, d10
4073; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
4074; CHECK-GI-NEXT:    ret
4075entry:
4076  %c = call <3 x double> @llvm.log2.v3f64(<3 x double> %a)
4077  ret <3 x double> %c
4078}
4079
4080define <4 x double> @log2_v4f64(<4 x double> %a) {
4081; CHECK-SD-LABEL: log2_v4f64:
4082; CHECK-SD:       // %bb.0: // %entry
4083; CHECK-SD-NEXT:    sub sp, sp, #64
4084; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
4085; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
4086; CHECK-SD-NEXT:    .cfi_offset w30, -16
4087; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4088; CHECK-SD-NEXT:    mov d0, v0.d[1]
4089; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4090; CHECK-SD-NEXT:    bl log2
4091; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
4092; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4093; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4094; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
4095; CHECK-SD-NEXT:    bl log2
4096; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4097; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
4098; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
4099; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4100; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
4101; CHECK-SD-NEXT:    mov d0, v0.d[1]
4102; CHECK-SD-NEXT:    bl log2
4103; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
4104; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4105; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
4106; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
4107; CHECK-SD-NEXT:    bl log2
4108; CHECK-SD-NEXT:    fmov d1, d0
4109; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
4110; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
4111; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
4112; CHECK-SD-NEXT:    add sp, sp, #64
4113; CHECK-SD-NEXT:    ret
4114;
4115; CHECK-GI-LABEL: log2_v4f64:
4116; CHECK-GI:       // %bb.0: // %entry
4117; CHECK-GI-NEXT:    sub sp, sp, #80
4118; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
4119; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
4120; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
4121; CHECK-GI-NEXT:    .cfi_offset w30, -16
4122; CHECK-GI-NEXT:    .cfi_offset b8, -24
4123; CHECK-GI-NEXT:    .cfi_offset b9, -32
4124; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
4125; CHECK-GI-NEXT:    mov d8, v0.d[1]
4126; CHECK-GI-NEXT:    mov d9, v1.d[1]
4127; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
4128; CHECK-GI-NEXT:    bl log2
4129; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4130; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4131; CHECK-GI-NEXT:    fmov d0, d8
4132; CHECK-GI-NEXT:    bl log2
4133; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4134; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4135; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4136; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
4137; CHECK-GI-NEXT:    bl log2
4138; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4139; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4140; CHECK-GI-NEXT:    fmov d0, d9
4141; CHECK-GI-NEXT:    bl log2
4142; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
4143; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4144; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
4145; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
4146; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
4147; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4148; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
4149; CHECK-GI-NEXT:    mov v0.16b, v2.16b
4150; CHECK-GI-NEXT:    add sp, sp, #80
4151; CHECK-GI-NEXT:    ret
4152entry:
4153  %c = call <4 x double> @llvm.log2.v4f64(<4 x double> %a)
4154  ret <4 x double> %c
4155}
4156
4157define <2 x float> @log2_v2f32(<2 x float> %a) {
4158; CHECK-SD-LABEL: log2_v2f32:
4159; CHECK-SD:       // %bb.0: // %entry
4160; CHECK-SD-NEXT:    sub sp, sp, #48
4161; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4162; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4163; CHECK-SD-NEXT:    .cfi_offset w30, -16
4164; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
4165; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4166; CHECK-SD-NEXT:    mov s0, v0.s[1]
4167; CHECK-SD-NEXT:    bl log2f
4168; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4169; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4170; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4171; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4172; CHECK-SD-NEXT:    bl log2f
4173; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4174; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4175; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4176; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4177; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
4178; CHECK-SD-NEXT:    add sp, sp, #48
4179; CHECK-SD-NEXT:    ret
4180;
4181; CHECK-GI-LABEL: log2_v2f32:
4182; CHECK-GI:       // %bb.0: // %entry
4183; CHECK-GI-NEXT:    sub sp, sp, #32
4184; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
4185; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
4186; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
4187; CHECK-GI-NEXT:    .cfi_offset w30, -8
4188; CHECK-GI-NEXT:    .cfi_offset b8, -16
4189; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4190; CHECK-GI-NEXT:    mov s8, v0.s[1]
4191; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4192; CHECK-GI-NEXT:    bl log2f
4193; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4194; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4195; CHECK-GI-NEXT:    fmov s0, s8
4196; CHECK-GI-NEXT:    bl log2f
4197; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4198; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4199; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
4200; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
4201; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
4202; CHECK-GI-NEXT:    fmov d0, d1
4203; CHECK-GI-NEXT:    add sp, sp, #32
4204; CHECK-GI-NEXT:    ret
4205entry:
4206  %c = call <2 x float> @llvm.log2.v2f32(<2 x float> %a)
4207  ret <2 x float> %c
4208}
4209
4210define <3 x float> @log2_v3f32(<3 x float> %a) {
4211; CHECK-SD-LABEL: log2_v3f32:
4212; CHECK-SD:       // %bb.0: // %entry
4213; CHECK-SD-NEXT:    sub sp, sp, #48
4214; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4215; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4216; CHECK-SD-NEXT:    .cfi_offset w30, -16
4217; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4218; CHECK-SD-NEXT:    mov s0, v0.s[1]
4219; CHECK-SD-NEXT:    bl log2f
4220; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4221; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4222; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4223; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4224; CHECK-SD-NEXT:    bl log2f
4225; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4226; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4227; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4228; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4229; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4230; CHECK-SD-NEXT:    mov s0, v0.s[2]
4231; CHECK-SD-NEXT:    bl log2f
4232; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4233; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4234; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4235; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
4236; CHECK-SD-NEXT:    mov v0.16b, v1.16b
4237; CHECK-SD-NEXT:    add sp, sp, #48
4238; CHECK-SD-NEXT:    ret
4239;
4240; CHECK-GI-LABEL: log2_v3f32:
4241; CHECK-GI:       // %bb.0: // %entry
4242; CHECK-GI-NEXT:    sub sp, sp, #64
4243; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
4244; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
4245; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
4246; CHECK-GI-NEXT:    .cfi_offset w30, -16
4247; CHECK-GI-NEXT:    .cfi_offset b8, -24
4248; CHECK-GI-NEXT:    .cfi_offset b9, -32
4249; CHECK-GI-NEXT:    mov s8, v0.s[1]
4250; CHECK-GI-NEXT:    mov s9, v0.s[2]
4251; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4252; CHECK-GI-NEXT:    bl log2f
4253; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4254; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4255; CHECK-GI-NEXT:    fmov s0, s8
4256; CHECK-GI-NEXT:    bl log2f
4257; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4258; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4259; CHECK-GI-NEXT:    fmov s0, s9
4260; CHECK-GI-NEXT:    bl log2f
4261; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
4262; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4263; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
4264; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
4265; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
4266; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
4267; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4268; CHECK-GI-NEXT:    add sp, sp, #64
4269; CHECK-GI-NEXT:    ret
4270entry:
4271  %c = call <3 x float> @llvm.log2.v3f32(<3 x float> %a)
4272  ret <3 x float> %c
4273}
4274
4275define <4 x float> @log2_v4f32(<4 x float> %a) {
4276; CHECK-SD-LABEL: log2_v4f32:
4277; CHECK-SD:       // %bb.0: // %entry
4278; CHECK-SD-NEXT:    sub sp, sp, #48
4279; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4280; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4281; CHECK-SD-NEXT:    .cfi_offset w30, -16
4282; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4283; CHECK-SD-NEXT:    mov s0, v0.s[1]
4284; CHECK-SD-NEXT:    bl log2f
4285; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4286; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4287; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4288; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4289; CHECK-SD-NEXT:    bl log2f
4290; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4291; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4292; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4293; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4294; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4295; CHECK-SD-NEXT:    mov s0, v0.s[2]
4296; CHECK-SD-NEXT:    bl log2f
4297; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4298; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4299; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
4300; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4301; CHECK-SD-NEXT:    mov s0, v0.s[3]
4302; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
4303; CHECK-SD-NEXT:    bl log2f
4304; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4305; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4306; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4307; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
4308; CHECK-SD-NEXT:    mov v0.16b, v1.16b
4309; CHECK-SD-NEXT:    add sp, sp, #48
4310; CHECK-SD-NEXT:    ret
4311;
4312; CHECK-GI-LABEL: log2_v4f32:
4313; CHECK-GI:       // %bb.0: // %entry
4314; CHECK-GI-NEXT:    sub sp, sp, #80
4315; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
4316; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
4317; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
4318; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
4319; CHECK-GI-NEXT:    .cfi_offset w30, -8
4320; CHECK-GI-NEXT:    .cfi_offset b8, -16
4321; CHECK-GI-NEXT:    .cfi_offset b9, -24
4322; CHECK-GI-NEXT:    .cfi_offset b10, -32
4323; CHECK-GI-NEXT:    mov s8, v0.s[1]
4324; CHECK-GI-NEXT:    mov s9, v0.s[2]
4325; CHECK-GI-NEXT:    mov s10, v0.s[3]
4326; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4327; CHECK-GI-NEXT:    bl log2f
4328; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4329; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4330; CHECK-GI-NEXT:    fmov s0, s8
4331; CHECK-GI-NEXT:    bl log2f
4332; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4333; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4334; CHECK-GI-NEXT:    fmov s0, s9
4335; CHECK-GI-NEXT:    bl log2f
4336; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4337; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4338; CHECK-GI-NEXT:    fmov s0, s10
4339; CHECK-GI-NEXT:    bl log2f
4340; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
4341; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4342; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
4343; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
4344; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
4345; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
4346; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
4347; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
4348; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
4349; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4350; CHECK-GI-NEXT:    add sp, sp, #80
4351; CHECK-GI-NEXT:    ret
4352entry:
4353  %c = call <4 x float> @llvm.log2.v4f32(<4 x float> %a)
4354  ret <4 x float> %c
4355}
4356
4357define <8 x float> @log2_v8f32(<8 x float> %a) {
4358; CHECK-SD-LABEL: log2_v8f32:
4359; CHECK-SD:       // %bb.0: // %entry
4360; CHECK-SD-NEXT:    sub sp, sp, #64
4361; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
4362; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
4363; CHECK-SD-NEXT:    .cfi_offset w30, -16
4364; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
4365; CHECK-SD-NEXT:    mov s0, v0.s[1]
4366; CHECK-SD-NEXT:    bl log2f
4367; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4368; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4369; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4370; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4371; CHECK-SD-NEXT:    bl log2f
4372; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4373; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4374; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4375; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4376; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4377; CHECK-SD-NEXT:    mov s0, v0.s[2]
4378; CHECK-SD-NEXT:    bl log2f
4379; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4380; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4381; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
4382; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4383; CHECK-SD-NEXT:    mov s0, v0.s[3]
4384; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4385; CHECK-SD-NEXT:    bl log2f
4386; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4387; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4388; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
4389; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4390; CHECK-SD-NEXT:    mov s0, v0.s[1]
4391; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4392; CHECK-SD-NEXT:    bl log2f
4393; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4394; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4395; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4396; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
4397; CHECK-SD-NEXT:    bl log2f
4398; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4399; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4400; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
4401; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4402; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4403; CHECK-SD-NEXT:    mov s0, v0.s[2]
4404; CHECK-SD-NEXT:    bl log2f
4405; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4406; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
4407; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
4408; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4409; CHECK-SD-NEXT:    mov s0, v0.s[3]
4410; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
4411; CHECK-SD-NEXT:    bl log2f
4412; CHECK-SD-NEXT:    fmov s2, s0
4413; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4414; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
4415; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
4416; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
4417; CHECK-SD-NEXT:    add sp, sp, #64
4418; CHECK-SD-NEXT:    ret
4419;
4420; CHECK-GI-LABEL: log2_v8f32:
4421; CHECK-GI:       // %bb.0: // %entry
4422; CHECK-GI-NEXT:    sub sp, sp, #176
4423; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
4424; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
4425; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
4426; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
4427; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
4428; CHECK-GI-NEXT:    .cfi_offset w30, -16
4429; CHECK-GI-NEXT:    .cfi_offset b8, -24
4430; CHECK-GI-NEXT:    .cfi_offset b9, -32
4431; CHECK-GI-NEXT:    .cfi_offset b10, -40
4432; CHECK-GI-NEXT:    .cfi_offset b11, -48
4433; CHECK-GI-NEXT:    .cfi_offset b12, -56
4434; CHECK-GI-NEXT:    .cfi_offset b13, -64
4435; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4436; CHECK-GI-NEXT:    mov s8, v0.s[1]
4437; CHECK-GI-NEXT:    mov s9, v0.s[2]
4438; CHECK-GI-NEXT:    mov s10, v0.s[3]
4439; CHECK-GI-NEXT:    mov s11, v1.s[1]
4440; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4441; CHECK-GI-NEXT:    mov s12, v1.s[2]
4442; CHECK-GI-NEXT:    mov s13, v1.s[3]
4443; CHECK-GI-NEXT:    bl log2f
4444; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4445; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
4446; CHECK-GI-NEXT:    fmov s0, s8
4447; CHECK-GI-NEXT:    bl log2f
4448; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4449; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
4450; CHECK-GI-NEXT:    fmov s0, s9
4451; CHECK-GI-NEXT:    bl log2f
4452; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4453; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
4454; CHECK-GI-NEXT:    fmov s0, s10
4455; CHECK-GI-NEXT:    bl log2f
4456; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4457; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
4458; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
4459; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
4460; CHECK-GI-NEXT:    bl log2f
4461; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4462; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4463; CHECK-GI-NEXT:    fmov s0, s11
4464; CHECK-GI-NEXT:    bl log2f
4465; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4466; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4467; CHECK-GI-NEXT:    fmov s0, s12
4468; CHECK-GI-NEXT:    bl log2f
4469; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4470; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4471; CHECK-GI-NEXT:    fmov s0, s13
4472; CHECK-GI-NEXT:    bl log2f
4473; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
4474; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
4475; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
4476; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
4477; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
4478; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
4479; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
4480; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
4481; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
4482; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
4483; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
4484; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
4485; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
4486; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
4487; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
4488; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
4489; CHECK-GI-NEXT:    mov v2.16b, v1.16b
4490; CHECK-GI-NEXT:    mov v1.16b, v3.16b
4491; CHECK-GI-NEXT:    mov v0.16b, v2.16b
4492; CHECK-GI-NEXT:    add sp, sp, #176
4493; CHECK-GI-NEXT:    ret
4494entry:
4495  %c = call <8 x float> @llvm.log2.v8f32(<8 x float> %a)
4496  ret <8 x float> %c
4497}
4498
4499define <7 x half> @log2_v7f16(<7 x half> %a) {
4500; CHECK-SD-LABEL: log2_v7f16:
4501; CHECK-SD:       // %bb.0: // %entry
4502; CHECK-SD-NEXT:    sub sp, sp, #48
4503; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4504; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4505; CHECK-SD-NEXT:    .cfi_offset w30, -16
4506; CHECK-SD-NEXT:    mov h1, v0.h[1]
4507; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4508; CHECK-SD-NEXT:    fcvt s0, h1
4509; CHECK-SD-NEXT:    bl log2f
4510; CHECK-SD-NEXT:    fcvt h0, s0
4511; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4512; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4513; CHECK-SD-NEXT:    fcvt s0, h0
4514; CHECK-SD-NEXT:    bl log2f
4515; CHECK-SD-NEXT:    fcvt h0, s0
4516; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4517; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
4518; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4519; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4520; CHECK-SD-NEXT:    mov h0, v0.h[2]
4521; CHECK-SD-NEXT:    fcvt s0, h0
4522; CHECK-SD-NEXT:    bl log2f
4523; CHECK-SD-NEXT:    fcvt h0, s0
4524; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4525; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
4526; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4527; CHECK-SD-NEXT:    mov h0, v0.h[3]
4528; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4529; CHECK-SD-NEXT:    fcvt s0, h0
4530; CHECK-SD-NEXT:    bl log2f
4531; CHECK-SD-NEXT:    fcvt h0, s0
4532; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4533; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
4534; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4535; CHECK-SD-NEXT:    mov h0, v0.h[4]
4536; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4537; CHECK-SD-NEXT:    fcvt s0, h0
4538; CHECK-SD-NEXT:    bl log2f
4539; CHECK-SD-NEXT:    fcvt h0, s0
4540; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4541; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
4542; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4543; CHECK-SD-NEXT:    mov h0, v0.h[5]
4544; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4545; CHECK-SD-NEXT:    fcvt s0, h0
4546; CHECK-SD-NEXT:    bl log2f
4547; CHECK-SD-NEXT:    fcvt h0, s0
4548; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4549; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
4550; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4551; CHECK-SD-NEXT:    mov h0, v0.h[6]
4552; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4553; CHECK-SD-NEXT:    fcvt s0, h0
4554; CHECK-SD-NEXT:    bl log2f
4555; CHECK-SD-NEXT:    fcvt h0, s0
4556; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4557; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
4558; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4559; CHECK-SD-NEXT:    mov h0, v0.h[7]
4560; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4561; CHECK-SD-NEXT:    fcvt s0, h0
4562; CHECK-SD-NEXT:    bl log2f
4563; CHECK-SD-NEXT:    fcvt h1, s0
4564; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4565; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4566; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
4567; CHECK-SD-NEXT:    add sp, sp, #48
4568; CHECK-SD-NEXT:    ret
4569;
4570; CHECK-GI-LABEL: log2_v7f16:
4571; CHECK-GI:       // %bb.0: // %entry
4572; CHECK-GI-NEXT:    sub sp, sp, #160
4573; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
4574; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
4575; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
4576; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
4577; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
4578; CHECK-GI-NEXT:    .cfi_offset w30, -16
4579; CHECK-GI-NEXT:    .cfi_offset b8, -24
4580; CHECK-GI-NEXT:    .cfi_offset b9, -32
4581; CHECK-GI-NEXT:    .cfi_offset b10, -40
4582; CHECK-GI-NEXT:    .cfi_offset b11, -48
4583; CHECK-GI-NEXT:    .cfi_offset b12, -56
4584; CHECK-GI-NEXT:    .cfi_offset b13, -64
4585; CHECK-GI-NEXT:    mov h8, v0.h[1]
4586; CHECK-GI-NEXT:    mov h9, v0.h[2]
4587; CHECK-GI-NEXT:    mov h10, v0.h[3]
4588; CHECK-GI-NEXT:    mov h11, v0.h[4]
4589; CHECK-GI-NEXT:    mov h12, v0.h[5]
4590; CHECK-GI-NEXT:    mov h13, v0.h[6]
4591; CHECK-GI-NEXT:    fcvt s0, h0
4592; CHECK-GI-NEXT:    bl log2f
4593; CHECK-GI-NEXT:    fcvt s1, h8
4594; CHECK-GI-NEXT:    fcvt h0, s0
4595; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
4596; CHECK-GI-NEXT:    fmov s0, s1
4597; CHECK-GI-NEXT:    bl log2f
4598; CHECK-GI-NEXT:    fcvt s1, h9
4599; CHECK-GI-NEXT:    fcvt h0, s0
4600; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
4601; CHECK-GI-NEXT:    fmov s0, s1
4602; CHECK-GI-NEXT:    bl log2f
4603; CHECK-GI-NEXT:    fcvt s1, h10
4604; CHECK-GI-NEXT:    fcvt h0, s0
4605; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
4606; CHECK-GI-NEXT:    fmov s0, s1
4607; CHECK-GI-NEXT:    bl log2f
4608; CHECK-GI-NEXT:    fcvt s1, h11
4609; CHECK-GI-NEXT:    fcvt h0, s0
4610; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4611; CHECK-GI-NEXT:    fmov s0, s1
4612; CHECK-GI-NEXT:    bl log2f
4613; CHECK-GI-NEXT:    fcvt s1, h12
4614; CHECK-GI-NEXT:    fcvt h0, s0
4615; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4616; CHECK-GI-NEXT:    fmov s0, s1
4617; CHECK-GI-NEXT:    bl log2f
4618; CHECK-GI-NEXT:    fcvt s1, h13
4619; CHECK-GI-NEXT:    fcvt h0, s0
4620; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4621; CHECK-GI-NEXT:    fmov s0, s1
4622; CHECK-GI-NEXT:    bl log2f
4623; CHECK-GI-NEXT:    ldp q3, q2, [sp, #48] // 32-byte Folded Reload
4624; CHECK-GI-NEXT:    fcvt h0, s0
4625; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
4626; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
4627; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
4628; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
4629; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
4630; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
4631; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
4632; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
4633; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
4634; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
4635; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
4636; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
4637; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
4638; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4639; CHECK-GI-NEXT:    add sp, sp, #160
4640; CHECK-GI-NEXT:    ret
4641entry:
4642  %c = call <7 x half> @llvm.log2.v7f16(<7 x half> %a)
4643  ret <7 x half> %c
4644}
4645
4646define <4 x half> @log2_v4f16(<4 x half> %a) {
4647; CHECK-SD-LABEL: log2_v4f16:
4648; CHECK-SD:       // %bb.0: // %entry
4649; CHECK-SD-NEXT:    sub sp, sp, #48
4650; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4651; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4652; CHECK-SD-NEXT:    .cfi_offset w30, -16
4653; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
4654; CHECK-SD-NEXT:    mov h1, v0.h[1]
4655; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4656; CHECK-SD-NEXT:    fcvt s0, h1
4657; CHECK-SD-NEXT:    bl log2f
4658; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4659; CHECK-SD-NEXT:    fcvt h0, s0
4660; CHECK-SD-NEXT:    fcvt s1, h1
4661; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4662; CHECK-SD-NEXT:    fmov s0, s1
4663; CHECK-SD-NEXT:    bl log2f
4664; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4665; CHECK-SD-NEXT:    fcvt h2, s0
4666; CHECK-SD-NEXT:    mov h1, v1.h[2]
4667; CHECK-SD-NEXT:    fcvt s0, h1
4668; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4669; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
4670; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
4671; CHECK-SD-NEXT:    bl log2f
4672; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4673; CHECK-SD-NEXT:    fcvt h2, s0
4674; CHECK-SD-NEXT:    mov h1, v1.h[3]
4675; CHECK-SD-NEXT:    fcvt s0, h1
4676; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
4677; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
4678; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
4679; CHECK-SD-NEXT:    bl log2f
4680; CHECK-SD-NEXT:    fcvt h1, s0
4681; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4682; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4683; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
4684; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
4685; CHECK-SD-NEXT:    add sp, sp, #48
4686; CHECK-SD-NEXT:    ret
4687;
4688; CHECK-GI-LABEL: log2_v4f16:
4689; CHECK-GI:       // %bb.0: // %entry
4690; CHECK-GI-NEXT:    sub sp, sp, #80
4691; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
4692; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
4693; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
4694; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
4695; CHECK-GI-NEXT:    .cfi_offset w30, -8
4696; CHECK-GI-NEXT:    .cfi_offset b8, -16
4697; CHECK-GI-NEXT:    .cfi_offset b9, -24
4698; CHECK-GI-NEXT:    .cfi_offset b10, -32
4699; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
4700; CHECK-GI-NEXT:    mov h8, v0.h[1]
4701; CHECK-GI-NEXT:    mov h9, v0.h[2]
4702; CHECK-GI-NEXT:    mov h10, v0.h[3]
4703; CHECK-GI-NEXT:    fcvt s0, h0
4704; CHECK-GI-NEXT:    bl log2f
4705; CHECK-GI-NEXT:    fcvt s1, h8
4706; CHECK-GI-NEXT:    fcvt h0, s0
4707; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4708; CHECK-GI-NEXT:    fmov s0, s1
4709; CHECK-GI-NEXT:    bl log2f
4710; CHECK-GI-NEXT:    fcvt s1, h9
4711; CHECK-GI-NEXT:    fcvt h0, s0
4712; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4713; CHECK-GI-NEXT:    fmov s0, s1
4714; CHECK-GI-NEXT:    bl log2f
4715; CHECK-GI-NEXT:    fcvt s1, h10
4716; CHECK-GI-NEXT:    fcvt h0, s0
4717; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4718; CHECK-GI-NEXT:    fmov s0, s1
4719; CHECK-GI-NEXT:    bl log2f
4720; CHECK-GI-NEXT:    ldp q3, q2, [sp] // 32-byte Folded Reload
4721; CHECK-GI-NEXT:    fcvt h0, s0
4722; CHECK-GI-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4723; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
4724; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
4725; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
4726; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
4727; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
4728; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
4729; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4730; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
4731; CHECK-GI-NEXT:    add sp, sp, #80
4732; CHECK-GI-NEXT:    ret
4733entry:
4734  %c = call <4 x half> @llvm.log2.v4f16(<4 x half> %a)
4735  ret <4 x half> %c
4736}
4737
4738define <8 x half> @log2_v8f16(<8 x half> %a) {
4739; CHECK-SD-LABEL: log2_v8f16:
4740; CHECK-SD:       // %bb.0: // %entry
4741; CHECK-SD-NEXT:    sub sp, sp, #48
4742; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
4743; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
4744; CHECK-SD-NEXT:    .cfi_offset w30, -16
4745; CHECK-SD-NEXT:    mov h1, v0.h[1]
4746; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
4747; CHECK-SD-NEXT:    fcvt s0, h1
4748; CHECK-SD-NEXT:    bl log2f
4749; CHECK-SD-NEXT:    fcvt h0, s0
4750; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4751; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4752; CHECK-SD-NEXT:    fcvt s0, h0
4753; CHECK-SD-NEXT:    bl log2f
4754; CHECK-SD-NEXT:    fcvt h0, s0
4755; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4756; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
4757; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4758; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4759; CHECK-SD-NEXT:    mov h0, v0.h[2]
4760; CHECK-SD-NEXT:    fcvt s0, h0
4761; CHECK-SD-NEXT:    bl log2f
4762; CHECK-SD-NEXT:    fcvt h0, s0
4763; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4764; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
4765; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4766; CHECK-SD-NEXT:    mov h0, v0.h[3]
4767; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4768; CHECK-SD-NEXT:    fcvt s0, h0
4769; CHECK-SD-NEXT:    bl log2f
4770; CHECK-SD-NEXT:    fcvt h0, s0
4771; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4772; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
4773; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4774; CHECK-SD-NEXT:    mov h0, v0.h[4]
4775; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4776; CHECK-SD-NEXT:    fcvt s0, h0
4777; CHECK-SD-NEXT:    bl log2f
4778; CHECK-SD-NEXT:    fcvt h0, s0
4779; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4780; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
4781; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4782; CHECK-SD-NEXT:    mov h0, v0.h[5]
4783; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4784; CHECK-SD-NEXT:    fcvt s0, h0
4785; CHECK-SD-NEXT:    bl log2f
4786; CHECK-SD-NEXT:    fcvt h0, s0
4787; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4788; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
4789; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4790; CHECK-SD-NEXT:    mov h0, v0.h[6]
4791; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4792; CHECK-SD-NEXT:    fcvt s0, h0
4793; CHECK-SD-NEXT:    bl log2f
4794; CHECK-SD-NEXT:    fcvt h0, s0
4795; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4796; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
4797; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4798; CHECK-SD-NEXT:    mov h0, v0.h[7]
4799; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4800; CHECK-SD-NEXT:    fcvt s0, h0
4801; CHECK-SD-NEXT:    bl log2f
4802; CHECK-SD-NEXT:    fcvt h1, s0
4803; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4804; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
4805; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
4806; CHECK-SD-NEXT:    add sp, sp, #48
4807; CHECK-SD-NEXT:    ret
4808;
4809; CHECK-GI-LABEL: log2_v8f16:
4810; CHECK-GI:       // %bb.0: // %entry
4811; CHECK-GI-NEXT:    sub sp, sp, #176
4812; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
4813; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
4814; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
4815; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
4816; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
4817; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
4818; CHECK-GI-NEXT:    .cfi_offset w30, -8
4819; CHECK-GI-NEXT:    .cfi_offset b8, -16
4820; CHECK-GI-NEXT:    .cfi_offset b9, -24
4821; CHECK-GI-NEXT:    .cfi_offset b10, -32
4822; CHECK-GI-NEXT:    .cfi_offset b11, -40
4823; CHECK-GI-NEXT:    .cfi_offset b12, -48
4824; CHECK-GI-NEXT:    .cfi_offset b13, -56
4825; CHECK-GI-NEXT:    .cfi_offset b14, -64
4826; CHECK-GI-NEXT:    mov h8, v0.h[1]
4827; CHECK-GI-NEXT:    mov h9, v0.h[2]
4828; CHECK-GI-NEXT:    mov h10, v0.h[3]
4829; CHECK-GI-NEXT:    mov h11, v0.h[4]
4830; CHECK-GI-NEXT:    mov h12, v0.h[5]
4831; CHECK-GI-NEXT:    mov h13, v0.h[6]
4832; CHECK-GI-NEXT:    mov h14, v0.h[7]
4833; CHECK-GI-NEXT:    fcvt s0, h0
4834; CHECK-GI-NEXT:    bl log2f
4835; CHECK-GI-NEXT:    fcvt s1, h8
4836; CHECK-GI-NEXT:    fcvt h0, s0
4837; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
4838; CHECK-GI-NEXT:    fmov s0, s1
4839; CHECK-GI-NEXT:    bl log2f
4840; CHECK-GI-NEXT:    fcvt s1, h9
4841; CHECK-GI-NEXT:    fcvt h0, s0
4842; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
4843; CHECK-GI-NEXT:    fmov s0, s1
4844; CHECK-GI-NEXT:    bl log2f
4845; CHECK-GI-NEXT:    fcvt s1, h10
4846; CHECK-GI-NEXT:    fcvt h0, s0
4847; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
4848; CHECK-GI-NEXT:    fmov s0, s1
4849; CHECK-GI-NEXT:    bl log2f
4850; CHECK-GI-NEXT:    fcvt s1, h11
4851; CHECK-GI-NEXT:    fcvt h0, s0
4852; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
4853; CHECK-GI-NEXT:    fmov s0, s1
4854; CHECK-GI-NEXT:    bl log2f
4855; CHECK-GI-NEXT:    fcvt s1, h12
4856; CHECK-GI-NEXT:    fcvt h0, s0
4857; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4858; CHECK-GI-NEXT:    fmov s0, s1
4859; CHECK-GI-NEXT:    bl log2f
4860; CHECK-GI-NEXT:    fcvt s1, h13
4861; CHECK-GI-NEXT:    fcvt h0, s0
4862; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4863; CHECK-GI-NEXT:    fmov s0, s1
4864; CHECK-GI-NEXT:    bl log2f
4865; CHECK-GI-NEXT:    fcvt s1, h14
4866; CHECK-GI-NEXT:    fcvt h0, s0
4867; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
4868; CHECK-GI-NEXT:    fmov s0, s1
4869; CHECK-GI-NEXT:    bl log2f
4870; CHECK-GI-NEXT:    ldp q3, q2, [sp, #64] // 32-byte Folded Reload
4871; CHECK-GI-NEXT:    fcvt h0, s0
4872; CHECK-GI-NEXT:    ldr q1, [sp, #96] // 16-byte Folded Reload
4873; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
4874; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
4875; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
4876; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
4877; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
4878; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
4879; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
4880; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
4881; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
4882; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
4883; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
4884; CHECK-GI-NEXT:    mov v1.h[5], v3.h[0]
4885; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
4886; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
4887; CHECK-GI-NEXT:    mov v0.16b, v1.16b
4888; CHECK-GI-NEXT:    add sp, sp, #176
4889; CHECK-GI-NEXT:    ret
4890entry:
4891  %c = call <8 x half> @llvm.log2.v8f16(<8 x half> %a)
4892  ret <8 x half> %c
4893}
4894
4895define <16 x half> @log2_v16f16(<16 x half> %a) {
4896; CHECK-SD-LABEL: log2_v16f16:
4897; CHECK-SD:       // %bb.0: // %entry
4898; CHECK-SD-NEXT:    sub sp, sp, #64
4899; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
4900; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
4901; CHECK-SD-NEXT:    .cfi_offset w30, -16
4902; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
4903; CHECK-SD-NEXT:    mov h1, v0.h[1]
4904; CHECK-SD-NEXT:    fcvt s0, h1
4905; CHECK-SD-NEXT:    bl log2f
4906; CHECK-SD-NEXT:    fcvt h0, s0
4907; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4908; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4909; CHECK-SD-NEXT:    fcvt s0, h0
4910; CHECK-SD-NEXT:    bl log2f
4911; CHECK-SD-NEXT:    fcvt h0, s0
4912; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4913; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
4914; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
4915; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4916; CHECK-SD-NEXT:    mov h0, v0.h[2]
4917; CHECK-SD-NEXT:    fcvt s0, h0
4918; CHECK-SD-NEXT:    bl log2f
4919; CHECK-SD-NEXT:    fcvt h0, s0
4920; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4921; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
4922; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4923; CHECK-SD-NEXT:    mov h0, v0.h[3]
4924; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4925; CHECK-SD-NEXT:    fcvt s0, h0
4926; CHECK-SD-NEXT:    bl log2f
4927; CHECK-SD-NEXT:    fcvt h0, s0
4928; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4929; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
4930; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4931; CHECK-SD-NEXT:    mov h0, v0.h[4]
4932; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4933; CHECK-SD-NEXT:    fcvt s0, h0
4934; CHECK-SD-NEXT:    bl log2f
4935; CHECK-SD-NEXT:    fcvt h0, s0
4936; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4937; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
4938; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4939; CHECK-SD-NEXT:    mov h0, v0.h[5]
4940; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4941; CHECK-SD-NEXT:    fcvt s0, h0
4942; CHECK-SD-NEXT:    bl log2f
4943; CHECK-SD-NEXT:    fcvt h0, s0
4944; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4945; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
4946; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4947; CHECK-SD-NEXT:    mov h0, v0.h[6]
4948; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4949; CHECK-SD-NEXT:    fcvt s0, h0
4950; CHECK-SD-NEXT:    bl log2f
4951; CHECK-SD-NEXT:    fcvt h0, s0
4952; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4953; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
4954; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
4955; CHECK-SD-NEXT:    mov h0, v0.h[7]
4956; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4957; CHECK-SD-NEXT:    fcvt s0, h0
4958; CHECK-SD-NEXT:    bl log2f
4959; CHECK-SD-NEXT:    fcvt h0, s0
4960; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
4961; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
4962; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4963; CHECK-SD-NEXT:    mov h0, v0.h[1]
4964; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
4965; CHECK-SD-NEXT:    fcvt s0, h0
4966; CHECK-SD-NEXT:    bl log2f
4967; CHECK-SD-NEXT:    fcvt h0, s0
4968; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4969; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4970; CHECK-SD-NEXT:    fcvt s0, h0
4971; CHECK-SD-NEXT:    bl log2f
4972; CHECK-SD-NEXT:    fcvt h0, s0
4973; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4974; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
4975; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
4976; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4977; CHECK-SD-NEXT:    mov h0, v0.h[2]
4978; CHECK-SD-NEXT:    fcvt s0, h0
4979; CHECK-SD-NEXT:    bl log2f
4980; CHECK-SD-NEXT:    fcvt h0, s0
4981; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4982; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
4983; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4984; CHECK-SD-NEXT:    mov h0, v0.h[3]
4985; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4986; CHECK-SD-NEXT:    fcvt s0, h0
4987; CHECK-SD-NEXT:    bl log2f
4988; CHECK-SD-NEXT:    fcvt h0, s0
4989; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4990; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
4991; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
4992; CHECK-SD-NEXT:    mov h0, v0.h[4]
4993; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
4994; CHECK-SD-NEXT:    fcvt s0, h0
4995; CHECK-SD-NEXT:    bl log2f
4996; CHECK-SD-NEXT:    fcvt h0, s0
4997; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
4998; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
4999; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5000; CHECK-SD-NEXT:    mov h0, v0.h[5]
5001; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5002; CHECK-SD-NEXT:    fcvt s0, h0
5003; CHECK-SD-NEXT:    bl log2f
5004; CHECK-SD-NEXT:    fcvt h0, s0
5005; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5006; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
5007; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5008; CHECK-SD-NEXT:    mov h0, v0.h[6]
5009; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5010; CHECK-SD-NEXT:    fcvt s0, h0
5011; CHECK-SD-NEXT:    bl log2f
5012; CHECK-SD-NEXT:    fcvt h0, s0
5013; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5014; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
5015; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5016; CHECK-SD-NEXT:    mov h0, v0.h[7]
5017; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5018; CHECK-SD-NEXT:    fcvt s0, h0
5019; CHECK-SD-NEXT:    bl log2f
5020; CHECK-SD-NEXT:    fmov s1, s0
5021; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
5022; CHECK-SD-NEXT:    fcvt h2, s1
5023; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
5024; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
5025; CHECK-SD-NEXT:    add sp, sp, #64
5026; CHECK-SD-NEXT:    ret
5027;
5028; CHECK-GI-LABEL: log2_v16f16:
5029; CHECK-GI:       // %bb.0: // %entry
5030; CHECK-GI-NEXT:    sub sp, sp, #320
5031; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
5032; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
5033; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
5034; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
5035; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
5036; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
5037; CHECK-GI-NEXT:    .cfi_offset w30, -8
5038; CHECK-GI-NEXT:    .cfi_offset w29, -16
5039; CHECK-GI-NEXT:    .cfi_offset b8, -24
5040; CHECK-GI-NEXT:    .cfi_offset b9, -32
5041; CHECK-GI-NEXT:    .cfi_offset b10, -40
5042; CHECK-GI-NEXT:    .cfi_offset b11, -48
5043; CHECK-GI-NEXT:    .cfi_offset b12, -56
5044; CHECK-GI-NEXT:    .cfi_offset b13, -64
5045; CHECK-GI-NEXT:    .cfi_offset b14, -72
5046; CHECK-GI-NEXT:    .cfi_offset b15, -80
5047; CHECK-GI-NEXT:    mov v2.16b, v1.16b
5048; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
5049; CHECK-GI-NEXT:    mov h14, v1.h[1]
5050; CHECK-GI-NEXT:    mov h1, v1.h[2]
5051; CHECK-GI-NEXT:    mov h15, v0.h[1]
5052; CHECK-GI-NEXT:    mov h8, v0.h[2]
5053; CHECK-GI-NEXT:    mov h9, v0.h[3]
5054; CHECK-GI-NEXT:    mov h10, v0.h[4]
5055; CHECK-GI-NEXT:    mov h11, v0.h[5]
5056; CHECK-GI-NEXT:    mov h12, v0.h[6]
5057; CHECK-GI-NEXT:    mov h13, v0.h[7]
5058; CHECK-GI-NEXT:    fcvt s0, h0
5059; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
5060; CHECK-GI-NEXT:    mov h1, v2.h[3]
5061; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
5062; CHECK-GI-NEXT:    mov h1, v2.h[4]
5063; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
5064; CHECK-GI-NEXT:    mov h1, v2.h[5]
5065; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
5066; CHECK-GI-NEXT:    mov h1, v2.h[6]
5067; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
5068; CHECK-GI-NEXT:    mov h1, v2.h[7]
5069; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
5070; CHECK-GI-NEXT:    bl log2f
5071; CHECK-GI-NEXT:    fcvt s1, h15
5072; CHECK-GI-NEXT:    fcvt h0, s0
5073; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
5074; CHECK-GI-NEXT:    fmov s0, s1
5075; CHECK-GI-NEXT:    bl log2f
5076; CHECK-GI-NEXT:    fcvt s1, h8
5077; CHECK-GI-NEXT:    fcvt h0, s0
5078; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
5079; CHECK-GI-NEXT:    fmov s0, s1
5080; CHECK-GI-NEXT:    bl log2f
5081; CHECK-GI-NEXT:    fcvt s1, h9
5082; CHECK-GI-NEXT:    fcvt h0, s0
5083; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
5084; CHECK-GI-NEXT:    fmov s0, s1
5085; CHECK-GI-NEXT:    bl log2f
5086; CHECK-GI-NEXT:    fcvt s1, h10
5087; CHECK-GI-NEXT:    fcvt h0, s0
5088; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
5089; CHECK-GI-NEXT:    fmov s0, s1
5090; CHECK-GI-NEXT:    bl log2f
5091; CHECK-GI-NEXT:    fcvt s1, h11
5092; CHECK-GI-NEXT:    fcvt h0, s0
5093; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
5094; CHECK-GI-NEXT:    fmov s0, s1
5095; CHECK-GI-NEXT:    bl log2f
5096; CHECK-GI-NEXT:    fcvt s1, h12
5097; CHECK-GI-NEXT:    fcvt h0, s0
5098; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
5099; CHECK-GI-NEXT:    fmov s0, s1
5100; CHECK-GI-NEXT:    bl log2f
5101; CHECK-GI-NEXT:    fcvt s1, h13
5102; CHECK-GI-NEXT:    fcvt h0, s0
5103; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
5104; CHECK-GI-NEXT:    fmov s0, s1
5105; CHECK-GI-NEXT:    bl log2f
5106; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
5107; CHECK-GI-NEXT:    fcvt h0, s0
5108; CHECK-GI-NEXT:    fcvt s1, h1
5109; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
5110; CHECK-GI-NEXT:    fmov s0, s1
5111; CHECK-GI-NEXT:    bl log2f
5112; CHECK-GI-NEXT:    fcvt s1, h14
5113; CHECK-GI-NEXT:    fcvt h0, s0
5114; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5115; CHECK-GI-NEXT:    fmov s0, s1
5116; CHECK-GI-NEXT:    bl log2f
5117; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
5118; CHECK-GI-NEXT:    fcvt h0, s0
5119; CHECK-GI-NEXT:    fcvt s1, h1
5120; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5121; CHECK-GI-NEXT:    fmov s0, s1
5122; CHECK-GI-NEXT:    bl log2f
5123; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
5124; CHECK-GI-NEXT:    fcvt h0, s0
5125; CHECK-GI-NEXT:    fcvt s1, h1
5126; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5127; CHECK-GI-NEXT:    fmov s0, s1
5128; CHECK-GI-NEXT:    bl log2f
5129; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
5130; CHECK-GI-NEXT:    fcvt h0, s0
5131; CHECK-GI-NEXT:    fcvt s1, h1
5132; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
5133; CHECK-GI-NEXT:    fmov s0, s1
5134; CHECK-GI-NEXT:    bl log2f
5135; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
5136; CHECK-GI-NEXT:    fcvt h0, s0
5137; CHECK-GI-NEXT:    fcvt s1, h1
5138; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
5139; CHECK-GI-NEXT:    fmov s0, s1
5140; CHECK-GI-NEXT:    bl log2f
5141; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
5142; CHECK-GI-NEXT:    fcvt h0, s0
5143; CHECK-GI-NEXT:    fcvt s1, h1
5144; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
5145; CHECK-GI-NEXT:    fmov s0, s1
5146; CHECK-GI-NEXT:    bl log2f
5147; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
5148; CHECK-GI-NEXT:    fcvt h0, s0
5149; CHECK-GI-NEXT:    fcvt s1, h1
5150; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
5151; CHECK-GI-NEXT:    fmov s0, s1
5152; CHECK-GI-NEXT:    bl log2f
5153; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
5154; CHECK-GI-NEXT:    ldr q2, [sp, #112] // 16-byte Folded Reload
5155; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
5156; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
5157; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
5158; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
5159; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
5160; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
5161; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
5162; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
5163; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
5164; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
5165; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
5166; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
5167; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
5168; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
5169; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
5170; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
5171; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
5172; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
5173; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
5174; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
5175; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
5176; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
5177; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
5178; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
5179; CHECK-GI-NEXT:    fcvt h2, s0
5180; CHECK-GI-NEXT:    ldr q0, [sp, #128] // 16-byte Folded Reload
5181; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
5182; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
5183; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
5184; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
5185; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
5186; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
5187; CHECK-GI-NEXT:    mov v0.16b, v3.16b
5188; CHECK-GI-NEXT:    add sp, sp, #320
5189; CHECK-GI-NEXT:    ret
5190entry:
5191  %c = call <16 x half> @llvm.log2.v16f16(<16 x half> %a)
5192  ret <16 x half> %c
5193}
5194
5195define <2 x fp128> @log2_v2fp128(<2 x fp128> %a) {
5196; CHECK-LABEL: log2_v2fp128:
5197; CHECK:       // %bb.0: // %entry
5198; CHECK-NEXT:    sub sp, sp, #48
5199; CHECK-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5200; CHECK-NEXT:    .cfi_def_cfa_offset 48
5201; CHECK-NEXT:    .cfi_offset w30, -16
5202; CHECK-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5203; CHECK-NEXT:    bl log2l
5204; CHECK-NEXT:    str q0, [sp] // 16-byte Folded Spill
5205; CHECK-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5206; CHECK-NEXT:    bl log2l
5207; CHECK-NEXT:    mov v1.16b, v0.16b
5208; CHECK-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5209; CHECK-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5210; CHECK-NEXT:    add sp, sp, #48
5211; CHECK-NEXT:    ret
5212entry:
5213  %c = call <2 x fp128> @llvm.log2.v2fp128(<2 x fp128> %a)
5214  ret <2 x fp128> %c
5215}
5216
5217define double @log10_f64(double %a) {
5218; CHECK-LABEL: log10_f64:
5219; CHECK:       // %bb.0: // %entry
5220; CHECK-NEXT:    b log10
5221entry:
5222  %c = call double @llvm.log10.f64(double %a)
5223  ret double %c
5224}
5225
5226define float @log10_f32(float %a) {
5227; CHECK-LABEL: log10_f32:
5228; CHECK:       // %bb.0: // %entry
5229; CHECK-NEXT:    b log10f
5230entry:
5231  %c = call float @llvm.log10.f32(float %a)
5232  ret float %c
5233}
5234
5235define half @log10_f16(half %a) {
5236; CHECK-LABEL: log10_f16:
5237; CHECK:       // %bb.0: // %entry
5238; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
5239; CHECK-NEXT:    .cfi_def_cfa_offset 16
5240; CHECK-NEXT:    .cfi_offset w30, -16
5241; CHECK-NEXT:    fcvt s0, h0
5242; CHECK-NEXT:    bl log10f
5243; CHECK-NEXT:    fcvt h0, s0
5244; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
5245; CHECK-NEXT:    ret
5246entry:
5247  %c = call half @llvm.log10.f16(half %a)
5248  ret half %c
5249}
5250
5251define fp128 @log10_fp128(fp128 %a) {
5252; CHECK-LABEL: log10_fp128:
5253; CHECK:       // %bb.0: // %entry
5254; CHECK-NEXT:    b log10l
5255entry:
5256  %c = call fp128 @llvm.log10.fp128(fp128 %a)
5257  ret fp128 %c
5258}
5259
5260define <1 x double> @log10_v1f64(<1 x double> %a) {
5261; CHECK-LABEL: log10_v1f64:
5262; CHECK:       // %bb.0: // %entry
5263; CHECK-NEXT:    str x30, [sp, #-16]! // 8-byte Folded Spill
5264; CHECK-NEXT:    .cfi_def_cfa_offset 16
5265; CHECK-NEXT:    .cfi_offset w30, -16
5266; CHECK-NEXT:    bl log10
5267; CHECK-NEXT:    ldr x30, [sp], #16 // 8-byte Folded Reload
5268; CHECK-NEXT:    ret
5269entry:
5270  %c = call <1 x double> @llvm.log10.v1f64(<1 x double> %a)
5271  ret <1 x double> %c
5272}
5273
5274define <2 x double> @log10_v2f64(<2 x double> %a) {
5275; CHECK-SD-LABEL: log10_v2f64:
5276; CHECK-SD:       // %bb.0: // %entry
5277; CHECK-SD-NEXT:    sub sp, sp, #48
5278; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5279; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5280; CHECK-SD-NEXT:    .cfi_offset w30, -16
5281; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5282; CHECK-SD-NEXT:    mov d0, v0.d[1]
5283; CHECK-SD-NEXT:    bl log10
5284; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5285; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5286; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5287; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5288; CHECK-SD-NEXT:    bl log10
5289; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5290; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5291; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5292; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
5293; CHECK-SD-NEXT:    add sp, sp, #48
5294; CHECK-SD-NEXT:    ret
5295;
5296; CHECK-GI-LABEL: log10_v2f64:
5297; CHECK-GI:       // %bb.0: // %entry
5298; CHECK-GI-NEXT:    sub sp, sp, #32
5299; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
5300; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
5301; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
5302; CHECK-GI-NEXT:    .cfi_offset w30, -8
5303; CHECK-GI-NEXT:    .cfi_offset b8, -16
5304; CHECK-GI-NEXT:    mov d8, v0.d[1]
5305; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
5306; CHECK-GI-NEXT:    bl log10
5307; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5308; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5309; CHECK-GI-NEXT:    fmov d0, d8
5310; CHECK-GI-NEXT:    bl log10
5311; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5312; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5313; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
5314; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
5315; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
5316; CHECK-GI-NEXT:    mov v0.16b, v1.16b
5317; CHECK-GI-NEXT:    add sp, sp, #32
5318; CHECK-GI-NEXT:    ret
5319entry:
5320  %c = call <2 x double> @llvm.log10.v2f64(<2 x double> %a)
5321  ret <2 x double> %c
5322}
5323
5324define <3 x double> @log10_v3f64(<3 x double> %a) {
5325; CHECK-SD-LABEL: log10_v3f64:
5326; CHECK-SD:       // %bb.0: // %entry
5327; CHECK-SD-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
5328; CHECK-SD-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
5329; CHECK-SD-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
5330; CHECK-SD-NEXT:    .cfi_def_cfa_offset 32
5331; CHECK-SD-NEXT:    .cfi_offset w30, -8
5332; CHECK-SD-NEXT:    .cfi_offset b8, -16
5333; CHECK-SD-NEXT:    .cfi_offset b9, -24
5334; CHECK-SD-NEXT:    .cfi_offset b10, -32
5335; CHECK-SD-NEXT:    fmov d8, d2
5336; CHECK-SD-NEXT:    fmov d9, d1
5337; CHECK-SD-NEXT:    bl log10
5338; CHECK-SD-NEXT:    fmov d10, d0
5339; CHECK-SD-NEXT:    fmov d0, d9
5340; CHECK-SD-NEXT:    bl log10
5341; CHECK-SD-NEXT:    fmov d9, d0
5342; CHECK-SD-NEXT:    fmov d0, d8
5343; CHECK-SD-NEXT:    bl log10
5344; CHECK-SD-NEXT:    fmov d1, d9
5345; CHECK-SD-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
5346; CHECK-SD-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
5347; CHECK-SD-NEXT:    fmov d2, d0
5348; CHECK-SD-NEXT:    fmov d0, d10
5349; CHECK-SD-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
5350; CHECK-SD-NEXT:    ret
5351;
5352; CHECK-GI-LABEL: log10_v3f64:
5353; CHECK-GI:       // %bb.0: // %entry
5354; CHECK-GI-NEXT:    str d10, [sp, #-32]! // 8-byte Folded Spill
5355; CHECK-GI-NEXT:    stp d9, d8, [sp, #8] // 16-byte Folded Spill
5356; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
5357; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
5358; CHECK-GI-NEXT:    .cfi_offset w30, -8
5359; CHECK-GI-NEXT:    .cfi_offset b8, -16
5360; CHECK-GI-NEXT:    .cfi_offset b9, -24
5361; CHECK-GI-NEXT:    .cfi_offset b10, -32
5362; CHECK-GI-NEXT:    fmov d8, d1
5363; CHECK-GI-NEXT:    fmov d9, d2
5364; CHECK-GI-NEXT:    bl log10
5365; CHECK-GI-NEXT:    fmov d10, d0
5366; CHECK-GI-NEXT:    fmov d0, d8
5367; CHECK-GI-NEXT:    bl log10
5368; CHECK-GI-NEXT:    fmov d8, d0
5369; CHECK-GI-NEXT:    fmov d0, d9
5370; CHECK-GI-NEXT:    bl log10
5371; CHECK-GI-NEXT:    fmov d1, d8
5372; CHECK-GI-NEXT:    ldp d9, d8, [sp, #8] // 16-byte Folded Reload
5373; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
5374; CHECK-GI-NEXT:    fmov d2, d0
5375; CHECK-GI-NEXT:    fmov d0, d10
5376; CHECK-GI-NEXT:    ldr d10, [sp], #32 // 8-byte Folded Reload
5377; CHECK-GI-NEXT:    ret
5378entry:
5379  %c = call <3 x double> @llvm.log10.v3f64(<3 x double> %a)
5380  ret <3 x double> %c
5381}
5382
5383define <4 x double> @log10_v4f64(<4 x double> %a) {
5384; CHECK-SD-LABEL: log10_v4f64:
5385; CHECK-SD:       // %bb.0: // %entry
5386; CHECK-SD-NEXT:    sub sp, sp, #64
5387; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
5388; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
5389; CHECK-SD-NEXT:    .cfi_offset w30, -16
5390; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5391; CHECK-SD-NEXT:    mov d0, v0.d[1]
5392; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
5393; CHECK-SD-NEXT:    bl log10
5394; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5395; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5396; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5397; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5398; CHECK-SD-NEXT:    bl log10
5399; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5400; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5401; CHECK-SD-NEXT:    mov v0.d[1], v1.d[0]
5402; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5403; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
5404; CHECK-SD-NEXT:    mov d0, v0.d[1]
5405; CHECK-SD-NEXT:    bl log10
5406; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5407; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5408; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
5409; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5410; CHECK-SD-NEXT:    bl log10
5411; CHECK-SD-NEXT:    fmov d1, d0
5412; CHECK-SD-NEXT:    ldp q2, q0, [sp] // 32-byte Folded Reload
5413; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
5414; CHECK-SD-NEXT:    mov v1.d[1], v2.d[0]
5415; CHECK-SD-NEXT:    add sp, sp, #64
5416; CHECK-SD-NEXT:    ret
5417;
5418; CHECK-GI-LABEL: log10_v4f64:
5419; CHECK-GI:       // %bb.0: // %entry
5420; CHECK-GI-NEXT:    sub sp, sp, #80
5421; CHECK-GI-NEXT:    stp d9, d8, [sp, #48] // 16-byte Folded Spill
5422; CHECK-GI-NEXT:    str x30, [sp, #64] // 8-byte Folded Spill
5423; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
5424; CHECK-GI-NEXT:    .cfi_offset w30, -16
5425; CHECK-GI-NEXT:    .cfi_offset b8, -24
5426; CHECK-GI-NEXT:    .cfi_offset b9, -32
5427; CHECK-GI-NEXT:    str q1, [sp] // 16-byte Folded Spill
5428; CHECK-GI-NEXT:    mov d8, v0.d[1]
5429; CHECK-GI-NEXT:    mov d9, v1.d[1]
5430; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
5431; CHECK-GI-NEXT:    bl log10
5432; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5433; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5434; CHECK-GI-NEXT:    fmov d0, d8
5435; CHECK-GI-NEXT:    bl log10
5436; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5437; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5438; CHECK-GI-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5439; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
5440; CHECK-GI-NEXT:    bl log10
5441; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5442; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5443; CHECK-GI-NEXT:    fmov d0, d9
5444; CHECK-GI-NEXT:    bl log10
5445; CHECK-GI-NEXT:    ldp q1, q2, [sp, #16] // 32-byte Folded Reload
5446; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5447; CHECK-GI-NEXT:    ldr x30, [sp, #64] // 8-byte Folded Reload
5448; CHECK-GI-NEXT:    ldp d9, d8, [sp, #48] // 16-byte Folded Reload
5449; CHECK-GI-NEXT:    mov v2.d[1], v1.d[0]
5450; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5451; CHECK-GI-NEXT:    mov v1.d[1], v0.d[0]
5452; CHECK-GI-NEXT:    mov v0.16b, v2.16b
5453; CHECK-GI-NEXT:    add sp, sp, #80
5454; CHECK-GI-NEXT:    ret
5455entry:
5456  %c = call <4 x double> @llvm.log10.v4f64(<4 x double> %a)
5457  ret <4 x double> %c
5458}
5459
5460define <2 x float> @log10_v2f32(<2 x float> %a) {
5461; CHECK-SD-LABEL: log10_v2f32:
5462; CHECK-SD:       // %bb.0: // %entry
5463; CHECK-SD-NEXT:    sub sp, sp, #48
5464; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5465; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5466; CHECK-SD-NEXT:    .cfi_offset w30, -16
5467; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5468; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5469; CHECK-SD-NEXT:    mov s0, v0.s[1]
5470; CHECK-SD-NEXT:    bl log10f
5471; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5472; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5473; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5474; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5475; CHECK-SD-NEXT:    bl log10f
5476; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5477; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5478; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5479; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5480; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5481; CHECK-SD-NEXT:    add sp, sp, #48
5482; CHECK-SD-NEXT:    ret
5483;
5484; CHECK-GI-LABEL: log10_v2f32:
5485; CHECK-GI:       // %bb.0: // %entry
5486; CHECK-GI-NEXT:    sub sp, sp, #32
5487; CHECK-GI-NEXT:    str d8, [sp, #16] // 8-byte Folded Spill
5488; CHECK-GI-NEXT:    str x30, [sp, #24] // 8-byte Folded Spill
5489; CHECK-GI-NEXT:    .cfi_def_cfa_offset 32
5490; CHECK-GI-NEXT:    .cfi_offset w30, -8
5491; CHECK-GI-NEXT:    .cfi_offset b8, -16
5492; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
5493; CHECK-GI-NEXT:    mov s8, v0.s[1]
5494; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5495; CHECK-GI-NEXT:    bl log10f
5496; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5497; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5498; CHECK-GI-NEXT:    fmov s0, s8
5499; CHECK-GI-NEXT:    bl log10f
5500; CHECK-GI-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5501; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5502; CHECK-GI-NEXT:    ldr x30, [sp, #24] // 8-byte Folded Reload
5503; CHECK-GI-NEXT:    ldr d8, [sp, #16] // 8-byte Folded Reload
5504; CHECK-GI-NEXT:    mov v1.s[1], v0.s[0]
5505; CHECK-GI-NEXT:    fmov d0, d1
5506; CHECK-GI-NEXT:    add sp, sp, #32
5507; CHECK-GI-NEXT:    ret
5508entry:
5509  %c = call <2 x float> @llvm.log10.v2f32(<2 x float> %a)
5510  ret <2 x float> %c
5511}
5512
5513define <3 x float> @log10_v3f32(<3 x float> %a) {
5514; CHECK-SD-LABEL: log10_v3f32:
5515; CHECK-SD:       // %bb.0: // %entry
5516; CHECK-SD-NEXT:    sub sp, sp, #48
5517; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5518; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5519; CHECK-SD-NEXT:    .cfi_offset w30, -16
5520; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5521; CHECK-SD-NEXT:    mov s0, v0.s[1]
5522; CHECK-SD-NEXT:    bl log10f
5523; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5524; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5525; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5526; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5527; CHECK-SD-NEXT:    bl log10f
5528; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5529; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5530; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5531; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5532; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5533; CHECK-SD-NEXT:    mov s0, v0.s[2]
5534; CHECK-SD-NEXT:    bl log10f
5535; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5536; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5537; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5538; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
5539; CHECK-SD-NEXT:    mov v0.16b, v1.16b
5540; CHECK-SD-NEXT:    add sp, sp, #48
5541; CHECK-SD-NEXT:    ret
5542;
5543; CHECK-GI-LABEL: log10_v3f32:
5544; CHECK-GI:       // %bb.0: // %entry
5545; CHECK-GI-NEXT:    sub sp, sp, #64
5546; CHECK-GI-NEXT:    stp d9, d8, [sp, #32] // 16-byte Folded Spill
5547; CHECK-GI-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
5548; CHECK-GI-NEXT:    .cfi_def_cfa_offset 64
5549; CHECK-GI-NEXT:    .cfi_offset w30, -16
5550; CHECK-GI-NEXT:    .cfi_offset b8, -24
5551; CHECK-GI-NEXT:    .cfi_offset b9, -32
5552; CHECK-GI-NEXT:    mov s8, v0.s[1]
5553; CHECK-GI-NEXT:    mov s9, v0.s[2]
5554; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5555; CHECK-GI-NEXT:    bl log10f
5556; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5557; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5558; CHECK-GI-NEXT:    fmov s0, s8
5559; CHECK-GI-NEXT:    bl log10f
5560; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5561; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5562; CHECK-GI-NEXT:    fmov s0, s9
5563; CHECK-GI-NEXT:    bl log10f
5564; CHECK-GI-NEXT:    ldp q2, q1, [sp] // 32-byte Folded Reload
5565; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5566; CHECK-GI-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
5567; CHECK-GI-NEXT:    ldp d9, d8, [sp, #32] // 16-byte Folded Reload
5568; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
5569; CHECK-GI-NEXT:    mov v1.s[2], v0.s[0]
5570; CHECK-GI-NEXT:    mov v0.16b, v1.16b
5571; CHECK-GI-NEXT:    add sp, sp, #64
5572; CHECK-GI-NEXT:    ret
5573entry:
5574  %c = call <3 x float> @llvm.log10.v3f32(<3 x float> %a)
5575  ret <3 x float> %c
5576}
5577
5578define <4 x float> @log10_v4f32(<4 x float> %a) {
5579; CHECK-SD-LABEL: log10_v4f32:
5580; CHECK-SD:       // %bb.0: // %entry
5581; CHECK-SD-NEXT:    sub sp, sp, #48
5582; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5583; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5584; CHECK-SD-NEXT:    .cfi_offset w30, -16
5585; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5586; CHECK-SD-NEXT:    mov s0, v0.s[1]
5587; CHECK-SD-NEXT:    bl log10f
5588; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5589; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5590; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5591; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5592; CHECK-SD-NEXT:    bl log10f
5593; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5594; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5595; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5596; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5597; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5598; CHECK-SD-NEXT:    mov s0, v0.s[2]
5599; CHECK-SD-NEXT:    bl log10f
5600; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5601; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5602; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
5603; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5604; CHECK-SD-NEXT:    mov s0, v0.s[3]
5605; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
5606; CHECK-SD-NEXT:    bl log10f
5607; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5608; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5609; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5610; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
5611; CHECK-SD-NEXT:    mov v0.16b, v1.16b
5612; CHECK-SD-NEXT:    add sp, sp, #48
5613; CHECK-SD-NEXT:    ret
5614;
5615; CHECK-GI-LABEL: log10_v4f32:
5616; CHECK-GI:       // %bb.0: // %entry
5617; CHECK-GI-NEXT:    sub sp, sp, #80
5618; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
5619; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
5620; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
5621; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
5622; CHECK-GI-NEXT:    .cfi_offset w30, -8
5623; CHECK-GI-NEXT:    .cfi_offset b8, -16
5624; CHECK-GI-NEXT:    .cfi_offset b9, -24
5625; CHECK-GI-NEXT:    .cfi_offset b10, -32
5626; CHECK-GI-NEXT:    mov s8, v0.s[1]
5627; CHECK-GI-NEXT:    mov s9, v0.s[2]
5628; CHECK-GI-NEXT:    mov s10, v0.s[3]
5629; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5630; CHECK-GI-NEXT:    bl log10f
5631; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5632; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5633; CHECK-GI-NEXT:    fmov s0, s8
5634; CHECK-GI-NEXT:    bl log10f
5635; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5636; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5637; CHECK-GI-NEXT:    fmov s0, s9
5638; CHECK-GI-NEXT:    bl log10f
5639; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5640; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5641; CHECK-GI-NEXT:    fmov s0, s10
5642; CHECK-GI-NEXT:    bl log10f
5643; CHECK-GI-NEXT:    ldp q2, q1, [sp, #16] // 32-byte Folded Reload
5644; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5645; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
5646; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
5647; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
5648; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
5649; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
5650; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
5651; CHECK-GI-NEXT:    mov v1.s[3], v0.s[0]
5652; CHECK-GI-NEXT:    mov v0.16b, v1.16b
5653; CHECK-GI-NEXT:    add sp, sp, #80
5654; CHECK-GI-NEXT:    ret
5655entry:
5656  %c = call <4 x float> @llvm.log10.v4f32(<4 x float> %a)
5657  ret <4 x float> %c
5658}
5659
5660define <8 x float> @log10_v8f32(<8 x float> %a) {
5661; CHECK-SD-LABEL: log10_v8f32:
5662; CHECK-SD:       // %bb.0: // %entry
5663; CHECK-SD-NEXT:    sub sp, sp, #64
5664; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
5665; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
5666; CHECK-SD-NEXT:    .cfi_offset w30, -16
5667; CHECK-SD-NEXT:    stp q0, q1, [sp] // 32-byte Folded Spill
5668; CHECK-SD-NEXT:    mov s0, v0.s[1]
5669; CHECK-SD-NEXT:    bl log10f
5670; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5671; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5672; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5673; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5674; CHECK-SD-NEXT:    bl log10f
5675; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
5676; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5677; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5678; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5679; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5680; CHECK-SD-NEXT:    mov s0, v0.s[2]
5681; CHECK-SD-NEXT:    bl log10f
5682; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
5683; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5684; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
5685; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5686; CHECK-SD-NEXT:    mov s0, v0.s[3]
5687; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
5688; CHECK-SD-NEXT:    bl log10f
5689; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
5690; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5691; CHECK-SD-NEXT:    mov v1.s[3], v0.s[0]
5692; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5693; CHECK-SD-NEXT:    mov s0, v0.s[1]
5694; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
5695; CHECK-SD-NEXT:    bl log10f
5696; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5697; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5698; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5699; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 killed $q0
5700; CHECK-SD-NEXT:    bl log10f
5701; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5702; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5703; CHECK-SD-NEXT:    mov v0.s[1], v1.s[0]
5704; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5705; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5706; CHECK-SD-NEXT:    mov s0, v0.s[2]
5707; CHECK-SD-NEXT:    bl log10f
5708; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5709; CHECK-SD-NEXT:    // kill: def $s0 killed $s0 def $q0
5710; CHECK-SD-NEXT:    mov v1.s[2], v0.s[0]
5711; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5712; CHECK-SD-NEXT:    mov s0, v0.s[3]
5713; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
5714; CHECK-SD-NEXT:    bl log10f
5715; CHECK-SD-NEXT:    fmov s2, s0
5716; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5717; CHECK-SD-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
5718; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
5719; CHECK-SD-NEXT:    mov v1.s[3], v2.s[0]
5720; CHECK-SD-NEXT:    add sp, sp, #64
5721; CHECK-SD-NEXT:    ret
5722;
5723; CHECK-GI-LABEL: log10_v8f32:
5724; CHECK-GI:       // %bb.0: // %entry
5725; CHECK-GI-NEXT:    sub sp, sp, #176
5726; CHECK-GI-NEXT:    stp d13, d12, [sp, #112] // 16-byte Folded Spill
5727; CHECK-GI-NEXT:    stp d11, d10, [sp, #128] // 16-byte Folded Spill
5728; CHECK-GI-NEXT:    stp d9, d8, [sp, #144] // 16-byte Folded Spill
5729; CHECK-GI-NEXT:    str x30, [sp, #160] // 8-byte Folded Spill
5730; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
5731; CHECK-GI-NEXT:    .cfi_offset w30, -16
5732; CHECK-GI-NEXT:    .cfi_offset b8, -24
5733; CHECK-GI-NEXT:    .cfi_offset b9, -32
5734; CHECK-GI-NEXT:    .cfi_offset b10, -40
5735; CHECK-GI-NEXT:    .cfi_offset b11, -48
5736; CHECK-GI-NEXT:    .cfi_offset b12, -56
5737; CHECK-GI-NEXT:    .cfi_offset b13, -64
5738; CHECK-GI-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
5739; CHECK-GI-NEXT:    mov s8, v0.s[1]
5740; CHECK-GI-NEXT:    mov s9, v0.s[2]
5741; CHECK-GI-NEXT:    mov s10, v0.s[3]
5742; CHECK-GI-NEXT:    mov s11, v1.s[1]
5743; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5744; CHECK-GI-NEXT:    mov s12, v1.s[2]
5745; CHECK-GI-NEXT:    mov s13, v1.s[3]
5746; CHECK-GI-NEXT:    bl log10f
5747; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5748; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
5749; CHECK-GI-NEXT:    fmov s0, s8
5750; CHECK-GI-NEXT:    bl log10f
5751; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5752; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
5753; CHECK-GI-NEXT:    fmov s0, s9
5754; CHECK-GI-NEXT:    bl log10f
5755; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5756; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
5757; CHECK-GI-NEXT:    fmov s0, s10
5758; CHECK-GI-NEXT:    bl log10f
5759; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5760; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
5761; CHECK-GI-NEXT:    ldr q0, [sp, #32] // 16-byte Folded Reload
5762; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 killed $q0
5763; CHECK-GI-NEXT:    bl log10f
5764; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5765; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5766; CHECK-GI-NEXT:    fmov s0, s11
5767; CHECK-GI-NEXT:    bl log10f
5768; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5769; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5770; CHECK-GI-NEXT:    fmov s0, s12
5771; CHECK-GI-NEXT:    bl log10f
5772; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5773; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5774; CHECK-GI-NEXT:    fmov s0, s13
5775; CHECK-GI-NEXT:    bl log10f
5776; CHECK-GI-NEXT:    ldp q2, q1, [sp, #48] // 32-byte Folded Reload
5777; CHECK-GI-NEXT:    // kill: def $s0 killed $s0 def $q0
5778; CHECK-GI-NEXT:    ldr x30, [sp, #160] // 8-byte Folded Reload
5779; CHECK-GI-NEXT:    ldp d9, d8, [sp, #144] // 16-byte Folded Reload
5780; CHECK-GI-NEXT:    ldp d11, d10, [sp, #128] // 16-byte Folded Reload
5781; CHECK-GI-NEXT:    mov v1.s[1], v2.s[0]
5782; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
5783; CHECK-GI-NEXT:    ldp d13, d12, [sp, #112] // 16-byte Folded Reload
5784; CHECK-GI-NEXT:    mov v3.s[1], v2.s[0]
5785; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
5786; CHECK-GI-NEXT:    mov v1.s[2], v2.s[0]
5787; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
5788; CHECK-GI-NEXT:    mov v3.s[2], v2.s[0]
5789; CHECK-GI-NEXT:    ldr q2, [sp, #80] // 16-byte Folded Reload
5790; CHECK-GI-NEXT:    mov v1.s[3], v2.s[0]
5791; CHECK-GI-NEXT:    mov v3.s[3], v0.s[0]
5792; CHECK-GI-NEXT:    mov v2.16b, v1.16b
5793; CHECK-GI-NEXT:    mov v1.16b, v3.16b
5794; CHECK-GI-NEXT:    mov v0.16b, v2.16b
5795; CHECK-GI-NEXT:    add sp, sp, #176
5796; CHECK-GI-NEXT:    ret
5797entry:
5798  %c = call <8 x float> @llvm.log10.v8f32(<8 x float> %a)
5799  ret <8 x float> %c
5800}
5801
5802define <7 x half> @log10_v7f16(<7 x half> %a) {
5803; CHECK-SD-LABEL: log10_v7f16:
5804; CHECK-SD:       // %bb.0: // %entry
5805; CHECK-SD-NEXT:    sub sp, sp, #48
5806; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5807; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5808; CHECK-SD-NEXT:    .cfi_offset w30, -16
5809; CHECK-SD-NEXT:    mov h1, v0.h[1]
5810; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5811; CHECK-SD-NEXT:    fcvt s0, h1
5812; CHECK-SD-NEXT:    bl log10f
5813; CHECK-SD-NEXT:    fcvt h0, s0
5814; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5815; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5816; CHECK-SD-NEXT:    fcvt s0, h0
5817; CHECK-SD-NEXT:    bl log10f
5818; CHECK-SD-NEXT:    fcvt h0, s0
5819; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5820; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
5821; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5822; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5823; CHECK-SD-NEXT:    mov h0, v0.h[2]
5824; CHECK-SD-NEXT:    fcvt s0, h0
5825; CHECK-SD-NEXT:    bl log10f
5826; CHECK-SD-NEXT:    fcvt h0, s0
5827; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5828; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
5829; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5830; CHECK-SD-NEXT:    mov h0, v0.h[3]
5831; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5832; CHECK-SD-NEXT:    fcvt s0, h0
5833; CHECK-SD-NEXT:    bl log10f
5834; CHECK-SD-NEXT:    fcvt h0, s0
5835; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5836; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
5837; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5838; CHECK-SD-NEXT:    mov h0, v0.h[4]
5839; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5840; CHECK-SD-NEXT:    fcvt s0, h0
5841; CHECK-SD-NEXT:    bl log10f
5842; CHECK-SD-NEXT:    fcvt h0, s0
5843; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5844; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
5845; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5846; CHECK-SD-NEXT:    mov h0, v0.h[5]
5847; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5848; CHECK-SD-NEXT:    fcvt s0, h0
5849; CHECK-SD-NEXT:    bl log10f
5850; CHECK-SD-NEXT:    fcvt h0, s0
5851; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5852; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
5853; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5854; CHECK-SD-NEXT:    mov h0, v0.h[6]
5855; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5856; CHECK-SD-NEXT:    fcvt s0, h0
5857; CHECK-SD-NEXT:    bl log10f
5858; CHECK-SD-NEXT:    fcvt h0, s0
5859; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5860; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
5861; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5862; CHECK-SD-NEXT:    mov h0, v0.h[7]
5863; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
5864; CHECK-SD-NEXT:    fcvt s0, h0
5865; CHECK-SD-NEXT:    bl log10f
5866; CHECK-SD-NEXT:    fcvt h1, s0
5867; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
5868; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5869; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
5870; CHECK-SD-NEXT:    add sp, sp, #48
5871; CHECK-SD-NEXT:    ret
5872;
5873; CHECK-GI-LABEL: log10_v7f16:
5874; CHECK-GI:       // %bb.0: // %entry
5875; CHECK-GI-NEXT:    sub sp, sp, #160
5876; CHECK-GI-NEXT:    stp d13, d12, [sp, #96] // 16-byte Folded Spill
5877; CHECK-GI-NEXT:    stp d11, d10, [sp, #112] // 16-byte Folded Spill
5878; CHECK-GI-NEXT:    stp d9, d8, [sp, #128] // 16-byte Folded Spill
5879; CHECK-GI-NEXT:    str x30, [sp, #144] // 8-byte Folded Spill
5880; CHECK-GI-NEXT:    .cfi_def_cfa_offset 160
5881; CHECK-GI-NEXT:    .cfi_offset w30, -16
5882; CHECK-GI-NEXT:    .cfi_offset b8, -24
5883; CHECK-GI-NEXT:    .cfi_offset b9, -32
5884; CHECK-GI-NEXT:    .cfi_offset b10, -40
5885; CHECK-GI-NEXT:    .cfi_offset b11, -48
5886; CHECK-GI-NEXT:    .cfi_offset b12, -56
5887; CHECK-GI-NEXT:    .cfi_offset b13, -64
5888; CHECK-GI-NEXT:    mov h8, v0.h[1]
5889; CHECK-GI-NEXT:    mov h9, v0.h[2]
5890; CHECK-GI-NEXT:    mov h10, v0.h[3]
5891; CHECK-GI-NEXT:    mov h11, v0.h[4]
5892; CHECK-GI-NEXT:    mov h12, v0.h[5]
5893; CHECK-GI-NEXT:    mov h13, v0.h[6]
5894; CHECK-GI-NEXT:    fcvt s0, h0
5895; CHECK-GI-NEXT:    bl log10f
5896; CHECK-GI-NEXT:    fcvt s1, h8
5897; CHECK-GI-NEXT:    fcvt h0, s0
5898; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
5899; CHECK-GI-NEXT:    fmov s0, s1
5900; CHECK-GI-NEXT:    bl log10f
5901; CHECK-GI-NEXT:    fcvt s1, h9
5902; CHECK-GI-NEXT:    fcvt h0, s0
5903; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
5904; CHECK-GI-NEXT:    fmov s0, s1
5905; CHECK-GI-NEXT:    bl log10f
5906; CHECK-GI-NEXT:    fcvt s1, h10
5907; CHECK-GI-NEXT:    fcvt h0, s0
5908; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
5909; CHECK-GI-NEXT:    fmov s0, s1
5910; CHECK-GI-NEXT:    bl log10f
5911; CHECK-GI-NEXT:    fcvt s1, h11
5912; CHECK-GI-NEXT:    fcvt h0, s0
5913; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
5914; CHECK-GI-NEXT:    fmov s0, s1
5915; CHECK-GI-NEXT:    bl log10f
5916; CHECK-GI-NEXT:    fcvt s1, h12
5917; CHECK-GI-NEXT:    fcvt h0, s0
5918; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5919; CHECK-GI-NEXT:    fmov s0, s1
5920; CHECK-GI-NEXT:    bl log10f
5921; CHECK-GI-NEXT:    fcvt s1, h13
5922; CHECK-GI-NEXT:    fcvt h0, s0
5923; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
5924; CHECK-GI-NEXT:    fmov s0, s1
5925; CHECK-GI-NEXT:    bl log10f
5926; CHECK-GI-NEXT:    ldp q3, q2, [sp, #48] // 32-byte Folded Reload
5927; CHECK-GI-NEXT:    fcvt h0, s0
5928; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
5929; CHECK-GI-NEXT:    ldp d9, d8, [sp, #128] // 16-byte Folded Reload
5930; CHECK-GI-NEXT:    ldp d11, d10, [sp, #112] // 16-byte Folded Reload
5931; CHECK-GI-NEXT:    ldr x30, [sp, #144] // 8-byte Folded Reload
5932; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
5933; CHECK-GI-NEXT:    ldp d13, d12, [sp, #96] // 16-byte Folded Reload
5934; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
5935; CHECK-GI-NEXT:    ldp q2, q3, [sp, #16] // 32-byte Folded Reload
5936; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
5937; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
5938; CHECK-GI-NEXT:    ldr q2, [sp] // 16-byte Folded Reload
5939; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
5940; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
5941; CHECK-GI-NEXT:    mov v0.16b, v1.16b
5942; CHECK-GI-NEXT:    add sp, sp, #160
5943; CHECK-GI-NEXT:    ret
5944entry:
5945  %c = call <7 x half> @llvm.log10.v7f16(<7 x half> %a)
5946  ret <7 x half> %c
5947}
5948
5949define <4 x half> @log10_v4f16(<4 x half> %a) {
5950; CHECK-SD-LABEL: log10_v4f16:
5951; CHECK-SD:       // %bb.0: // %entry
5952; CHECK-SD-NEXT:    sub sp, sp, #48
5953; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
5954; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
5955; CHECK-SD-NEXT:    .cfi_offset w30, -16
5956; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 def $q0
5957; CHECK-SD-NEXT:    mov h1, v0.h[1]
5958; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
5959; CHECK-SD-NEXT:    fcvt s0, h1
5960; CHECK-SD-NEXT:    bl log10f
5961; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5962; CHECK-SD-NEXT:    fcvt h0, s0
5963; CHECK-SD-NEXT:    fcvt s1, h1
5964; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
5965; CHECK-SD-NEXT:    fmov s0, s1
5966; CHECK-SD-NEXT:    bl log10f
5967; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5968; CHECK-SD-NEXT:    fcvt h2, s0
5969; CHECK-SD-NEXT:    mov h1, v1.h[2]
5970; CHECK-SD-NEXT:    fcvt s0, h1
5971; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5972; CHECK-SD-NEXT:    mov v2.h[1], v1.h[0]
5973; CHECK-SD-NEXT:    str q2, [sp] // 16-byte Folded Spill
5974; CHECK-SD-NEXT:    bl log10f
5975; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
5976; CHECK-SD-NEXT:    fcvt h2, s0
5977; CHECK-SD-NEXT:    mov h1, v1.h[3]
5978; CHECK-SD-NEXT:    fcvt s0, h1
5979; CHECK-SD-NEXT:    ldr q1, [sp] // 16-byte Folded Reload
5980; CHECK-SD-NEXT:    mov v1.h[2], v2.h[0]
5981; CHECK-SD-NEXT:    str q1, [sp] // 16-byte Folded Spill
5982; CHECK-SD-NEXT:    bl log10f
5983; CHECK-SD-NEXT:    fcvt h1, s0
5984; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
5985; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
5986; CHECK-SD-NEXT:    mov v0.h[3], v1.h[0]
5987; CHECK-SD-NEXT:    // kill: def $d0 killed $d0 killed $q0
5988; CHECK-SD-NEXT:    add sp, sp, #48
5989; CHECK-SD-NEXT:    ret
5990;
5991; CHECK-GI-LABEL: log10_v4f16:
5992; CHECK-GI:       // %bb.0: // %entry
5993; CHECK-GI-NEXT:    sub sp, sp, #80
5994; CHECK-GI-NEXT:    str d10, [sp, #48] // 8-byte Folded Spill
5995; CHECK-GI-NEXT:    stp d9, d8, [sp, #56] // 16-byte Folded Spill
5996; CHECK-GI-NEXT:    str x30, [sp, #72] // 8-byte Folded Spill
5997; CHECK-GI-NEXT:    .cfi_def_cfa_offset 80
5998; CHECK-GI-NEXT:    .cfi_offset w30, -8
5999; CHECK-GI-NEXT:    .cfi_offset b8, -16
6000; CHECK-GI-NEXT:    .cfi_offset b9, -24
6001; CHECK-GI-NEXT:    .cfi_offset b10, -32
6002; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 def $q0
6003; CHECK-GI-NEXT:    mov h8, v0.h[1]
6004; CHECK-GI-NEXT:    mov h9, v0.h[2]
6005; CHECK-GI-NEXT:    mov h10, v0.h[3]
6006; CHECK-GI-NEXT:    fcvt s0, h0
6007; CHECK-GI-NEXT:    bl log10f
6008; CHECK-GI-NEXT:    fcvt s1, h8
6009; CHECK-GI-NEXT:    fcvt h0, s0
6010; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
6011; CHECK-GI-NEXT:    fmov s0, s1
6012; CHECK-GI-NEXT:    bl log10f
6013; CHECK-GI-NEXT:    fcvt s1, h9
6014; CHECK-GI-NEXT:    fcvt h0, s0
6015; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
6016; CHECK-GI-NEXT:    fmov s0, s1
6017; CHECK-GI-NEXT:    bl log10f
6018; CHECK-GI-NEXT:    fcvt s1, h10
6019; CHECK-GI-NEXT:    fcvt h0, s0
6020; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6021; CHECK-GI-NEXT:    fmov s0, s1
6022; CHECK-GI-NEXT:    bl log10f
6023; CHECK-GI-NEXT:    ldp q3, q2, [sp] // 32-byte Folded Reload
6024; CHECK-GI-NEXT:    fcvt h0, s0
6025; CHECK-GI-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6026; CHECK-GI-NEXT:    ldp d9, d8, [sp, #56] // 16-byte Folded Reload
6027; CHECK-GI-NEXT:    ldr x30, [sp, #72] // 8-byte Folded Reload
6028; CHECK-GI-NEXT:    ldr d10, [sp, #48] // 8-byte Folded Reload
6029; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
6030; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
6031; CHECK-GI-NEXT:    mov v1.h[3], v0.h[0]
6032; CHECK-GI-NEXT:    mov v0.16b, v1.16b
6033; CHECK-GI-NEXT:    // kill: def $d0 killed $d0 killed $q0
6034; CHECK-GI-NEXT:    add sp, sp, #80
6035; CHECK-GI-NEXT:    ret
6036entry:
6037  %c = call <4 x half> @llvm.log10.v4f16(<4 x half> %a)
6038  ret <4 x half> %c
6039}
6040
6041define <8 x half> @log10_v8f16(<8 x half> %a) {
6042; CHECK-SD-LABEL: log10_v8f16:
6043; CHECK-SD:       // %bb.0: // %entry
6044; CHECK-SD-NEXT:    sub sp, sp, #48
6045; CHECK-SD-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
6046; CHECK-SD-NEXT:    .cfi_def_cfa_offset 48
6047; CHECK-SD-NEXT:    .cfi_offset w30, -16
6048; CHECK-SD-NEXT:    mov h1, v0.h[1]
6049; CHECK-SD-NEXT:    str q0, [sp] // 16-byte Folded Spill
6050; CHECK-SD-NEXT:    fcvt s0, h1
6051; CHECK-SD-NEXT:    bl log10f
6052; CHECK-SD-NEXT:    fcvt h0, s0
6053; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6054; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6055; CHECK-SD-NEXT:    fcvt s0, h0
6056; CHECK-SD-NEXT:    bl log10f
6057; CHECK-SD-NEXT:    fcvt h0, s0
6058; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6059; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
6060; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6061; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6062; CHECK-SD-NEXT:    mov h0, v0.h[2]
6063; CHECK-SD-NEXT:    fcvt s0, h0
6064; CHECK-SD-NEXT:    bl log10f
6065; CHECK-SD-NEXT:    fcvt h0, s0
6066; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6067; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
6068; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6069; CHECK-SD-NEXT:    mov h0, v0.h[3]
6070; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6071; CHECK-SD-NEXT:    fcvt s0, h0
6072; CHECK-SD-NEXT:    bl log10f
6073; CHECK-SD-NEXT:    fcvt h0, s0
6074; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6075; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
6076; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6077; CHECK-SD-NEXT:    mov h0, v0.h[4]
6078; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6079; CHECK-SD-NEXT:    fcvt s0, h0
6080; CHECK-SD-NEXT:    bl log10f
6081; CHECK-SD-NEXT:    fcvt h0, s0
6082; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6083; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
6084; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6085; CHECK-SD-NEXT:    mov h0, v0.h[5]
6086; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6087; CHECK-SD-NEXT:    fcvt s0, h0
6088; CHECK-SD-NEXT:    bl log10f
6089; CHECK-SD-NEXT:    fcvt h0, s0
6090; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6091; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
6092; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6093; CHECK-SD-NEXT:    mov h0, v0.h[6]
6094; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6095; CHECK-SD-NEXT:    fcvt s0, h0
6096; CHECK-SD-NEXT:    bl log10f
6097; CHECK-SD-NEXT:    fcvt h0, s0
6098; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6099; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
6100; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6101; CHECK-SD-NEXT:    mov h0, v0.h[7]
6102; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6103; CHECK-SD-NEXT:    fcvt s0, h0
6104; CHECK-SD-NEXT:    bl log10f
6105; CHECK-SD-NEXT:    fcvt h1, s0
6106; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6107; CHECK-SD-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
6108; CHECK-SD-NEXT:    mov v0.h[7], v1.h[0]
6109; CHECK-SD-NEXT:    add sp, sp, #48
6110; CHECK-SD-NEXT:    ret
6111;
6112; CHECK-GI-LABEL: log10_v8f16:
6113; CHECK-GI:       // %bb.0: // %entry
6114; CHECK-GI-NEXT:    sub sp, sp, #176
6115; CHECK-GI-NEXT:    str d14, [sp, #112] // 8-byte Folded Spill
6116; CHECK-GI-NEXT:    stp d13, d12, [sp, #120] // 16-byte Folded Spill
6117; CHECK-GI-NEXT:    stp d11, d10, [sp, #136] // 16-byte Folded Spill
6118; CHECK-GI-NEXT:    stp d9, d8, [sp, #152] // 16-byte Folded Spill
6119; CHECK-GI-NEXT:    str x30, [sp, #168] // 8-byte Folded Spill
6120; CHECK-GI-NEXT:    .cfi_def_cfa_offset 176
6121; CHECK-GI-NEXT:    .cfi_offset w30, -8
6122; CHECK-GI-NEXT:    .cfi_offset b8, -16
6123; CHECK-GI-NEXT:    .cfi_offset b9, -24
6124; CHECK-GI-NEXT:    .cfi_offset b10, -32
6125; CHECK-GI-NEXT:    .cfi_offset b11, -40
6126; CHECK-GI-NEXT:    .cfi_offset b12, -48
6127; CHECK-GI-NEXT:    .cfi_offset b13, -56
6128; CHECK-GI-NEXT:    .cfi_offset b14, -64
6129; CHECK-GI-NEXT:    mov h8, v0.h[1]
6130; CHECK-GI-NEXT:    mov h9, v0.h[2]
6131; CHECK-GI-NEXT:    mov h10, v0.h[3]
6132; CHECK-GI-NEXT:    mov h11, v0.h[4]
6133; CHECK-GI-NEXT:    mov h12, v0.h[5]
6134; CHECK-GI-NEXT:    mov h13, v0.h[6]
6135; CHECK-GI-NEXT:    mov h14, v0.h[7]
6136; CHECK-GI-NEXT:    fcvt s0, h0
6137; CHECK-GI-NEXT:    bl log10f
6138; CHECK-GI-NEXT:    fcvt s1, h8
6139; CHECK-GI-NEXT:    fcvt h0, s0
6140; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
6141; CHECK-GI-NEXT:    fmov s0, s1
6142; CHECK-GI-NEXT:    bl log10f
6143; CHECK-GI-NEXT:    fcvt s1, h9
6144; CHECK-GI-NEXT:    fcvt h0, s0
6145; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
6146; CHECK-GI-NEXT:    fmov s0, s1
6147; CHECK-GI-NEXT:    bl log10f
6148; CHECK-GI-NEXT:    fcvt s1, h10
6149; CHECK-GI-NEXT:    fcvt h0, s0
6150; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
6151; CHECK-GI-NEXT:    fmov s0, s1
6152; CHECK-GI-NEXT:    bl log10f
6153; CHECK-GI-NEXT:    fcvt s1, h11
6154; CHECK-GI-NEXT:    fcvt h0, s0
6155; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
6156; CHECK-GI-NEXT:    fmov s0, s1
6157; CHECK-GI-NEXT:    bl log10f
6158; CHECK-GI-NEXT:    fcvt s1, h12
6159; CHECK-GI-NEXT:    fcvt h0, s0
6160; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
6161; CHECK-GI-NEXT:    fmov s0, s1
6162; CHECK-GI-NEXT:    bl log10f
6163; CHECK-GI-NEXT:    fcvt s1, h13
6164; CHECK-GI-NEXT:    fcvt h0, s0
6165; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6166; CHECK-GI-NEXT:    fmov s0, s1
6167; CHECK-GI-NEXT:    bl log10f
6168; CHECK-GI-NEXT:    fcvt s1, h14
6169; CHECK-GI-NEXT:    fcvt h0, s0
6170; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
6171; CHECK-GI-NEXT:    fmov s0, s1
6172; CHECK-GI-NEXT:    bl log10f
6173; CHECK-GI-NEXT:    ldp q3, q2, [sp, #64] // 32-byte Folded Reload
6174; CHECK-GI-NEXT:    fcvt h0, s0
6175; CHECK-GI-NEXT:    ldr q1, [sp, #96] // 16-byte Folded Reload
6176; CHECK-GI-NEXT:    ldp d9, d8, [sp, #152] // 16-byte Folded Reload
6177; CHECK-GI-NEXT:    ldp d11, d10, [sp, #136] // 16-byte Folded Reload
6178; CHECK-GI-NEXT:    ldr x30, [sp, #168] // 8-byte Folded Reload
6179; CHECK-GI-NEXT:    mov v1.h[1], v3.h[0]
6180; CHECK-GI-NEXT:    ldr d14, [sp, #112] // 8-byte Folded Reload
6181; CHECK-GI-NEXT:    ldp d13, d12, [sp, #120] // 16-byte Folded Reload
6182; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
6183; CHECK-GI-NEXT:    ldp q2, q3, [sp, #32] // 32-byte Folded Reload
6184; CHECK-GI-NEXT:    mov v1.h[3], v3.h[0]
6185; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
6186; CHECK-GI-NEXT:    ldp q2, q3, [sp] // 32-byte Folded Reload
6187; CHECK-GI-NEXT:    mov v1.h[5], v3.h[0]
6188; CHECK-GI-NEXT:    mov v1.h[6], v2.h[0]
6189; CHECK-GI-NEXT:    mov v1.h[7], v0.h[0]
6190; CHECK-GI-NEXT:    mov v0.16b, v1.16b
6191; CHECK-GI-NEXT:    add sp, sp, #176
6192; CHECK-GI-NEXT:    ret
6193entry:
6194  %c = call <8 x half> @llvm.log10.v8f16(<8 x half> %a)
6195  ret <8 x half> %c
6196}
6197
6198define <16 x half> @log10_v16f16(<16 x half> %a) {
6199; CHECK-SD-LABEL: log10_v16f16:
6200; CHECK-SD:       // %bb.0: // %entry
6201; CHECK-SD-NEXT:    sub sp, sp, #64
6202; CHECK-SD-NEXT:    str x30, [sp, #48] // 8-byte Folded Spill
6203; CHECK-SD-NEXT:    .cfi_def_cfa_offset 64
6204; CHECK-SD-NEXT:    .cfi_offset w30, -16
6205; CHECK-SD-NEXT:    stp q1, q0, [sp] // 32-byte Folded Spill
6206; CHECK-SD-NEXT:    mov h1, v0.h[1]
6207; CHECK-SD-NEXT:    fcvt s0, h1
6208; CHECK-SD-NEXT:    bl log10f
6209; CHECK-SD-NEXT:    fcvt h0, s0
6210; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
6211; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6212; CHECK-SD-NEXT:    fcvt s0, h0
6213; CHECK-SD-NEXT:    bl log10f
6214; CHECK-SD-NEXT:    fcvt h0, s0
6215; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6216; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
6217; CHECK-SD-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
6218; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6219; CHECK-SD-NEXT:    mov h0, v0.h[2]
6220; CHECK-SD-NEXT:    fcvt s0, h0
6221; CHECK-SD-NEXT:    bl log10f
6222; CHECK-SD-NEXT:    fcvt h0, s0
6223; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6224; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
6225; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6226; CHECK-SD-NEXT:    mov h0, v0.h[3]
6227; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6228; CHECK-SD-NEXT:    fcvt s0, h0
6229; CHECK-SD-NEXT:    bl log10f
6230; CHECK-SD-NEXT:    fcvt h0, s0
6231; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6232; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
6233; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6234; CHECK-SD-NEXT:    mov h0, v0.h[4]
6235; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6236; CHECK-SD-NEXT:    fcvt s0, h0
6237; CHECK-SD-NEXT:    bl log10f
6238; CHECK-SD-NEXT:    fcvt h0, s0
6239; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6240; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
6241; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6242; CHECK-SD-NEXT:    mov h0, v0.h[5]
6243; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6244; CHECK-SD-NEXT:    fcvt s0, h0
6245; CHECK-SD-NEXT:    bl log10f
6246; CHECK-SD-NEXT:    fcvt h0, s0
6247; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6248; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
6249; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6250; CHECK-SD-NEXT:    mov h0, v0.h[6]
6251; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6252; CHECK-SD-NEXT:    fcvt s0, h0
6253; CHECK-SD-NEXT:    bl log10f
6254; CHECK-SD-NEXT:    fcvt h0, s0
6255; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6256; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
6257; CHECK-SD-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6258; CHECK-SD-NEXT:    mov h0, v0.h[7]
6259; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6260; CHECK-SD-NEXT:    fcvt s0, h0
6261; CHECK-SD-NEXT:    bl log10f
6262; CHECK-SD-NEXT:    fcvt h0, s0
6263; CHECK-SD-NEXT:    ldr q1, [sp, #32] // 16-byte Folded Reload
6264; CHECK-SD-NEXT:    mov v1.h[7], v0.h[0]
6265; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6266; CHECK-SD-NEXT:    mov h0, v0.h[1]
6267; CHECK-SD-NEXT:    str q1, [sp, #32] // 16-byte Folded Spill
6268; CHECK-SD-NEXT:    fcvt s0, h0
6269; CHECK-SD-NEXT:    bl log10f
6270; CHECK-SD-NEXT:    fcvt h0, s0
6271; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6272; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6273; CHECK-SD-NEXT:    fcvt s0, h0
6274; CHECK-SD-NEXT:    bl log10f
6275; CHECK-SD-NEXT:    fcvt h0, s0
6276; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6277; CHECK-SD-NEXT:    mov v0.h[1], v1.h[0]
6278; CHECK-SD-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6279; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6280; CHECK-SD-NEXT:    mov h0, v0.h[2]
6281; CHECK-SD-NEXT:    fcvt s0, h0
6282; CHECK-SD-NEXT:    bl log10f
6283; CHECK-SD-NEXT:    fcvt h0, s0
6284; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6285; CHECK-SD-NEXT:    mov v1.h[2], v0.h[0]
6286; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6287; CHECK-SD-NEXT:    mov h0, v0.h[3]
6288; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6289; CHECK-SD-NEXT:    fcvt s0, h0
6290; CHECK-SD-NEXT:    bl log10f
6291; CHECK-SD-NEXT:    fcvt h0, s0
6292; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6293; CHECK-SD-NEXT:    mov v1.h[3], v0.h[0]
6294; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6295; CHECK-SD-NEXT:    mov h0, v0.h[4]
6296; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6297; CHECK-SD-NEXT:    fcvt s0, h0
6298; CHECK-SD-NEXT:    bl log10f
6299; CHECK-SD-NEXT:    fcvt h0, s0
6300; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6301; CHECK-SD-NEXT:    mov v1.h[4], v0.h[0]
6302; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6303; CHECK-SD-NEXT:    mov h0, v0.h[5]
6304; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6305; CHECK-SD-NEXT:    fcvt s0, h0
6306; CHECK-SD-NEXT:    bl log10f
6307; CHECK-SD-NEXT:    fcvt h0, s0
6308; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6309; CHECK-SD-NEXT:    mov v1.h[5], v0.h[0]
6310; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6311; CHECK-SD-NEXT:    mov h0, v0.h[6]
6312; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6313; CHECK-SD-NEXT:    fcvt s0, h0
6314; CHECK-SD-NEXT:    bl log10f
6315; CHECK-SD-NEXT:    fcvt h0, s0
6316; CHECK-SD-NEXT:    ldr q1, [sp, #16] // 16-byte Folded Reload
6317; CHECK-SD-NEXT:    mov v1.h[6], v0.h[0]
6318; CHECK-SD-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6319; CHECK-SD-NEXT:    mov h0, v0.h[7]
6320; CHECK-SD-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6321; CHECK-SD-NEXT:    fcvt s0, h0
6322; CHECK-SD-NEXT:    bl log10f
6323; CHECK-SD-NEXT:    fmov s1, s0
6324; CHECK-SD-NEXT:    ldr x30, [sp, #48] // 8-byte Folded Reload
6325; CHECK-SD-NEXT:    fcvt h2, s1
6326; CHECK-SD-NEXT:    ldp q1, q0, [sp, #16] // 32-byte Folded Reload
6327; CHECK-SD-NEXT:    mov v1.h[7], v2.h[0]
6328; CHECK-SD-NEXT:    add sp, sp, #64
6329; CHECK-SD-NEXT:    ret
6330;
6331; CHECK-GI-LABEL: log10_v16f16:
6332; CHECK-GI:       // %bb.0: // %entry
6333; CHECK-GI-NEXT:    sub sp, sp, #320
6334; CHECK-GI-NEXT:    stp d15, d14, [sp, #240] // 16-byte Folded Spill
6335; CHECK-GI-NEXT:    stp d13, d12, [sp, #256] // 16-byte Folded Spill
6336; CHECK-GI-NEXT:    stp d11, d10, [sp, #272] // 16-byte Folded Spill
6337; CHECK-GI-NEXT:    stp d9, d8, [sp, #288] // 16-byte Folded Spill
6338; CHECK-GI-NEXT:    stp x29, x30, [sp, #304] // 16-byte Folded Spill
6339; CHECK-GI-NEXT:    .cfi_def_cfa_offset 320
6340; CHECK-GI-NEXT:    .cfi_offset w30, -8
6341; CHECK-GI-NEXT:    .cfi_offset w29, -16
6342; CHECK-GI-NEXT:    .cfi_offset b8, -24
6343; CHECK-GI-NEXT:    .cfi_offset b9, -32
6344; CHECK-GI-NEXT:    .cfi_offset b10, -40
6345; CHECK-GI-NEXT:    .cfi_offset b11, -48
6346; CHECK-GI-NEXT:    .cfi_offset b12, -56
6347; CHECK-GI-NEXT:    .cfi_offset b13, -64
6348; CHECK-GI-NEXT:    .cfi_offset b14, -72
6349; CHECK-GI-NEXT:    .cfi_offset b15, -80
6350; CHECK-GI-NEXT:    mov v2.16b, v1.16b
6351; CHECK-GI-NEXT:    str q1, [sp, #80] // 16-byte Folded Spill
6352; CHECK-GI-NEXT:    mov h14, v1.h[1]
6353; CHECK-GI-NEXT:    mov h1, v1.h[2]
6354; CHECK-GI-NEXT:    mov h15, v0.h[1]
6355; CHECK-GI-NEXT:    mov h8, v0.h[2]
6356; CHECK-GI-NEXT:    mov h9, v0.h[3]
6357; CHECK-GI-NEXT:    mov h10, v0.h[4]
6358; CHECK-GI-NEXT:    mov h11, v0.h[5]
6359; CHECK-GI-NEXT:    mov h12, v0.h[6]
6360; CHECK-GI-NEXT:    mov h13, v0.h[7]
6361; CHECK-GI-NEXT:    fcvt s0, h0
6362; CHECK-GI-NEXT:    str h1, [sp, #16] // 2-byte Folded Spill
6363; CHECK-GI-NEXT:    mov h1, v2.h[3]
6364; CHECK-GI-NEXT:    str h1, [sp, #32] // 2-byte Folded Spill
6365; CHECK-GI-NEXT:    mov h1, v2.h[4]
6366; CHECK-GI-NEXT:    str h1, [sp, #48] // 2-byte Folded Spill
6367; CHECK-GI-NEXT:    mov h1, v2.h[5]
6368; CHECK-GI-NEXT:    str h1, [sp, #64] // 2-byte Folded Spill
6369; CHECK-GI-NEXT:    mov h1, v2.h[6]
6370; CHECK-GI-NEXT:    str h1, [sp, #96] // 2-byte Folded Spill
6371; CHECK-GI-NEXT:    mov h1, v2.h[7]
6372; CHECK-GI-NEXT:    str h1, [sp, #160] // 2-byte Folded Spill
6373; CHECK-GI-NEXT:    bl log10f
6374; CHECK-GI-NEXT:    fcvt s1, h15
6375; CHECK-GI-NEXT:    fcvt h0, s0
6376; CHECK-GI-NEXT:    str q0, [sp, #192] // 16-byte Folded Spill
6377; CHECK-GI-NEXT:    fmov s0, s1
6378; CHECK-GI-NEXT:    bl log10f
6379; CHECK-GI-NEXT:    fcvt s1, h8
6380; CHECK-GI-NEXT:    fcvt h0, s0
6381; CHECK-GI-NEXT:    str q0, [sp, #112] // 16-byte Folded Spill
6382; CHECK-GI-NEXT:    fmov s0, s1
6383; CHECK-GI-NEXT:    bl log10f
6384; CHECK-GI-NEXT:    fcvt s1, h9
6385; CHECK-GI-NEXT:    fcvt h0, s0
6386; CHECK-GI-NEXT:    str q0, [sp, #224] // 16-byte Folded Spill
6387; CHECK-GI-NEXT:    fmov s0, s1
6388; CHECK-GI-NEXT:    bl log10f
6389; CHECK-GI-NEXT:    fcvt s1, h10
6390; CHECK-GI-NEXT:    fcvt h0, s0
6391; CHECK-GI-NEXT:    str q0, [sp, #208] // 16-byte Folded Spill
6392; CHECK-GI-NEXT:    fmov s0, s1
6393; CHECK-GI-NEXT:    bl log10f
6394; CHECK-GI-NEXT:    fcvt s1, h11
6395; CHECK-GI-NEXT:    fcvt h0, s0
6396; CHECK-GI-NEXT:    str q0, [sp, #176] // 16-byte Folded Spill
6397; CHECK-GI-NEXT:    fmov s0, s1
6398; CHECK-GI-NEXT:    bl log10f
6399; CHECK-GI-NEXT:    fcvt s1, h12
6400; CHECK-GI-NEXT:    fcvt h0, s0
6401; CHECK-GI-NEXT:    str q0, [sp, #144] // 16-byte Folded Spill
6402; CHECK-GI-NEXT:    fmov s0, s1
6403; CHECK-GI-NEXT:    bl log10f
6404; CHECK-GI-NEXT:    fcvt s1, h13
6405; CHECK-GI-NEXT:    fcvt h0, s0
6406; CHECK-GI-NEXT:    str q0, [sp, #128] // 16-byte Folded Spill
6407; CHECK-GI-NEXT:    fmov s0, s1
6408; CHECK-GI-NEXT:    bl log10f
6409; CHECK-GI-NEXT:    ldr q1, [sp, #80] // 16-byte Folded Reload
6410; CHECK-GI-NEXT:    fcvt h0, s0
6411; CHECK-GI-NEXT:    fcvt s1, h1
6412; CHECK-GI-NEXT:    str q0, [sp, #80] // 16-byte Folded Spill
6413; CHECK-GI-NEXT:    fmov s0, s1
6414; CHECK-GI-NEXT:    bl log10f
6415; CHECK-GI-NEXT:    fcvt s1, h14
6416; CHECK-GI-NEXT:    fcvt h0, s0
6417; CHECK-GI-NEXT:    str q0, [sp] // 16-byte Folded Spill
6418; CHECK-GI-NEXT:    fmov s0, s1
6419; CHECK-GI-NEXT:    bl log10f
6420; CHECK-GI-NEXT:    ldr h1, [sp, #16] // 2-byte Folded Reload
6421; CHECK-GI-NEXT:    fcvt h0, s0
6422; CHECK-GI-NEXT:    fcvt s1, h1
6423; CHECK-GI-NEXT:    str q0, [sp, #16] // 16-byte Folded Spill
6424; CHECK-GI-NEXT:    fmov s0, s1
6425; CHECK-GI-NEXT:    bl log10f
6426; CHECK-GI-NEXT:    ldr h1, [sp, #32] // 2-byte Folded Reload
6427; CHECK-GI-NEXT:    fcvt h0, s0
6428; CHECK-GI-NEXT:    fcvt s1, h1
6429; CHECK-GI-NEXT:    str q0, [sp, #32] // 16-byte Folded Spill
6430; CHECK-GI-NEXT:    fmov s0, s1
6431; CHECK-GI-NEXT:    bl log10f
6432; CHECK-GI-NEXT:    ldr h1, [sp, #48] // 2-byte Folded Reload
6433; CHECK-GI-NEXT:    fcvt h0, s0
6434; CHECK-GI-NEXT:    fcvt s1, h1
6435; CHECK-GI-NEXT:    str q0, [sp, #48] // 16-byte Folded Spill
6436; CHECK-GI-NEXT:    fmov s0, s1
6437; CHECK-GI-NEXT:    bl log10f
6438; CHECK-GI-NEXT:    ldr h1, [sp, #64] // 2-byte Folded Reload
6439; CHECK-GI-NEXT:    fcvt h0, s0
6440; CHECK-GI-NEXT:    fcvt s1, h1
6441; CHECK-GI-NEXT:    str q0, [sp, #64] // 16-byte Folded Spill
6442; CHECK-GI-NEXT:    fmov s0, s1
6443; CHECK-GI-NEXT:    bl log10f
6444; CHECK-GI-NEXT:    ldr h1, [sp, #96] // 2-byte Folded Reload
6445; CHECK-GI-NEXT:    fcvt h0, s0
6446; CHECK-GI-NEXT:    fcvt s1, h1
6447; CHECK-GI-NEXT:    str q0, [sp, #96] // 16-byte Folded Spill
6448; CHECK-GI-NEXT:    fmov s0, s1
6449; CHECK-GI-NEXT:    bl log10f
6450; CHECK-GI-NEXT:    ldr h1, [sp, #160] // 2-byte Folded Reload
6451; CHECK-GI-NEXT:    fcvt h0, s0
6452; CHECK-GI-NEXT:    fcvt s1, h1
6453; CHECK-GI-NEXT:    str q0, [sp, #160] // 16-byte Folded Spill
6454; CHECK-GI-NEXT:    fmov s0, s1
6455; CHECK-GI-NEXT:    bl log10f
6456; CHECK-GI-NEXT:    ldr q3, [sp, #192] // 16-byte Folded Reload
6457; CHECK-GI-NEXT:    ldr q2, [sp, #112] // 16-byte Folded Reload
6458; CHECK-GI-NEXT:    ldp x29, x30, [sp, #304] // 16-byte Folded Reload
6459; CHECK-GI-NEXT:    mov v3.h[1], v2.h[0]
6460; CHECK-GI-NEXT:    ldp q1, q2, [sp] // 32-byte Folded Reload
6461; CHECK-GI-NEXT:    ldp d9, d8, [sp, #288] // 16-byte Folded Reload
6462; CHECK-GI-NEXT:    ldp d11, d10, [sp, #272] // 16-byte Folded Reload
6463; CHECK-GI-NEXT:    mov v1.h[1], v2.h[0]
6464; CHECK-GI-NEXT:    ldr q2, [sp, #224] // 16-byte Folded Reload
6465; CHECK-GI-NEXT:    ldp d13, d12, [sp, #256] // 16-byte Folded Reload
6466; CHECK-GI-NEXT:    mov v3.h[2], v2.h[0]
6467; CHECK-GI-NEXT:    ldr q2, [sp, #32] // 16-byte Folded Reload
6468; CHECK-GI-NEXT:    ldp d15, d14, [sp, #240] // 16-byte Folded Reload
6469; CHECK-GI-NEXT:    mov v1.h[2], v2.h[0]
6470; CHECK-GI-NEXT:    ldr q2, [sp, #208] // 16-byte Folded Reload
6471; CHECK-GI-NEXT:    mov v3.h[3], v2.h[0]
6472; CHECK-GI-NEXT:    ldr q2, [sp, #48] // 16-byte Folded Reload
6473; CHECK-GI-NEXT:    mov v1.h[3], v2.h[0]
6474; CHECK-GI-NEXT:    ldr q2, [sp, #176] // 16-byte Folded Reload
6475; CHECK-GI-NEXT:    mov v3.h[4], v2.h[0]
6476; CHECK-GI-NEXT:    ldr q2, [sp, #64] // 16-byte Folded Reload
6477; CHECK-GI-NEXT:    mov v1.h[4], v2.h[0]
6478; CHECK-GI-NEXT:    ldr q2, [sp, #144] // 16-byte Folded Reload
6479; CHECK-GI-NEXT:    mov v3.h[5], v2.h[0]
6480; CHECK-GI-NEXT:    ldr q2, [sp, #96] // 16-byte Folded Reload
6481; CHECK-GI-NEXT:    mov v1.h[5], v2.h[0]
6482; CHECK-GI-NEXT:    fcvt h2, s0
6483; CHECK-GI-NEXT:    ldr q0, [sp, #128] // 16-byte Folded Reload
6484; CHECK-GI-NEXT:    mov v3.h[6], v0.h[0]
6485; CHECK-GI-NEXT:    ldr q0, [sp, #160] // 16-byte Folded Reload
6486; CHECK-GI-NEXT:    mov v1.h[6], v0.h[0]
6487; CHECK-GI-NEXT:    ldr q0, [sp, #80] // 16-byte Folded Reload
6488; CHECK-GI-NEXT:    mov v3.h[7], v0.h[0]
6489; CHECK-GI-NEXT:    mov v1.h[7], v2.h[0]
6490; CHECK-GI-NEXT:    mov v0.16b, v3.16b
6491; CHECK-GI-NEXT:    add sp, sp, #320
6492; CHECK-GI-NEXT:    ret
6493entry:
6494  %c = call <16 x half> @llvm.log10.v16f16(<16 x half> %a)
6495  ret <16 x half> %c
6496}
6497
6498define <2 x fp128> @log10_v2fp128(<2 x fp128> %a) {
6499; CHECK-LABEL: log10_v2fp128:
6500; CHECK:       // %bb.0: // %entry
6501; CHECK-NEXT:    sub sp, sp, #48
6502; CHECK-NEXT:    str x30, [sp, #32] // 8-byte Folded Spill
6503; CHECK-NEXT:    .cfi_def_cfa_offset 48
6504; CHECK-NEXT:    .cfi_offset w30, -16
6505; CHECK-NEXT:    str q1, [sp, #16] // 16-byte Folded Spill
6506; CHECK-NEXT:    bl log10l
6507; CHECK-NEXT:    str q0, [sp] // 16-byte Folded Spill
6508; CHECK-NEXT:    ldr q0, [sp, #16] // 16-byte Folded Reload
6509; CHECK-NEXT:    bl log10l
6510; CHECK-NEXT:    mov v1.16b, v0.16b
6511; CHECK-NEXT:    ldr q0, [sp] // 16-byte Folded Reload
6512; CHECK-NEXT:    ldr x30, [sp, #32] // 8-byte Folded Reload
6513; CHECK-NEXT:    add sp, sp, #48
6514; CHECK-NEXT:    ret
6515entry:
6516  %c = call <2 x fp128> @llvm.log10.v2fp128(<2 x fp128> %a)
6517  ret <2 x fp128> %c
6518}
6519
6520declare <1 x double> @llvm.exp.v1f64(<1 x double>)
6521declare <1 x double> @llvm.exp2.v1f64(<1 x double>)
6522declare <1 x double> @llvm.log.v1f64(<1 x double>)
6523declare <1 x double> @llvm.log10.v1f64(<1 x double>)
6524declare <1 x double> @llvm.log2.v1f64(<1 x double>)
6525declare <16 x half> @llvm.exp.v16f16(<16 x half>)
6526declare <16 x half> @llvm.exp2.v16f16(<16 x half>)
6527declare <16 x half> @llvm.log.v16f16(<16 x half>)
6528declare <16 x half> @llvm.log10.v16f16(<16 x half>)
6529declare <16 x half> @llvm.log2.v16f16(<16 x half>)
6530declare <2 x double> @llvm.exp.v2f64(<2 x double>)
6531declare <2 x double> @llvm.exp2.v2f64(<2 x double>)
6532declare <2 x double> @llvm.log.v2f64(<2 x double>)
6533declare <2 x double> @llvm.log10.v2f64(<2 x double>)
6534declare <2 x double> @llvm.log2.v2f64(<2 x double>)
6535declare <2 x float> @llvm.exp.v2f32(<2 x float>)
6536declare <2 x float> @llvm.exp2.v2f32(<2 x float>)
6537declare <2 x float> @llvm.log.v2f32(<2 x float>)
6538declare <2 x float> @llvm.log10.v2f32(<2 x float>)
6539declare <2 x float> @llvm.log2.v2f32(<2 x float>)
6540declare <2 x fp128> @llvm.exp.v2fp128(<2 x fp128>)
6541declare <2 x fp128> @llvm.exp2.v2fp128(<2 x fp128>)
6542declare <2 x fp128> @llvm.log.v2fp128(<2 x fp128>)
6543declare <2 x fp128> @llvm.log10.v2fp128(<2 x fp128>)
6544declare <2 x fp128> @llvm.log2.v2fp128(<2 x fp128>)
6545declare <3 x double> @llvm.exp.v3f64(<3 x double>)
6546declare <3 x double> @llvm.exp2.v3f64(<3 x double>)
6547declare <3 x double> @llvm.log.v3f64(<3 x double>)
6548declare <3 x double> @llvm.log10.v3f64(<3 x double>)
6549declare <3 x double> @llvm.log2.v3f64(<3 x double>)
6550declare <3 x float> @llvm.exp.v3f32(<3 x float>)
6551declare <3 x float> @llvm.exp2.v3f32(<3 x float>)
6552declare <3 x float> @llvm.log.v3f32(<3 x float>)
6553declare <3 x float> @llvm.log10.v3f32(<3 x float>)
6554declare <3 x float> @llvm.log2.v3f32(<3 x float>)
6555declare <4 x double> @llvm.exp.v4f64(<4 x double>)
6556declare <4 x double> @llvm.exp2.v4f64(<4 x double>)
6557declare <4 x double> @llvm.log.v4f64(<4 x double>)
6558declare <4 x double> @llvm.log10.v4f64(<4 x double>)
6559declare <4 x double> @llvm.log2.v4f64(<4 x double>)
6560declare <4 x float> @llvm.exp.v4f32(<4 x float>)
6561declare <4 x float> @llvm.exp2.v4f32(<4 x float>)
6562declare <4 x float> @llvm.log.v4f32(<4 x float>)
6563declare <4 x float> @llvm.log10.v4f32(<4 x float>)
6564declare <4 x float> @llvm.log2.v4f32(<4 x float>)
6565declare <4 x half> @llvm.exp.v4f16(<4 x half>)
6566declare <4 x half> @llvm.exp2.v4f16(<4 x half>)
6567declare <4 x half> @llvm.log.v4f16(<4 x half>)
6568declare <4 x half> @llvm.log10.v4f16(<4 x half>)
6569declare <4 x half> @llvm.log2.v4f16(<4 x half>)
6570declare <7 x half> @llvm.exp.v7f16(<7 x half>)
6571declare <7 x half> @llvm.exp2.v7f16(<7 x half>)
6572declare <7 x half> @llvm.log.v7f16(<7 x half>)
6573declare <7 x half> @llvm.log10.v7f16(<7 x half>)
6574declare <7 x half> @llvm.log2.v7f16(<7 x half>)
6575declare <8 x float> @llvm.exp.v8f32(<8 x float>)
6576declare <8 x float> @llvm.exp2.v8f32(<8 x float>)
6577declare <8 x float> @llvm.log.v8f32(<8 x float>)
6578declare <8 x float> @llvm.log10.v8f32(<8 x float>)
6579declare <8 x float> @llvm.log2.v8f32(<8 x float>)
6580declare <8 x half> @llvm.exp.v8f16(<8 x half>)
6581declare <8 x half> @llvm.exp2.v8f16(<8 x half>)
6582declare <8 x half> @llvm.log.v8f16(<8 x half>)
6583declare <8 x half> @llvm.log10.v8f16(<8 x half>)
6584declare <8 x half> @llvm.log2.v8f16(<8 x half>)
6585declare double @llvm.exp.f64(double)
6586declare double @llvm.exp2.f64(double)
6587declare double @llvm.log.f64(double)
6588declare double @llvm.log10.f64(double)
6589declare double @llvm.log2.f64(double)
6590declare float @llvm.exp.f32(float)
6591declare float @llvm.exp2.f32(float)
6592declare float @llvm.log.f32(float)
6593declare float @llvm.log10.f32(float)
6594declare float @llvm.log2.f32(float)
6595declare fp128 @llvm.exp.fp128(fp128)
6596declare fp128 @llvm.exp2.fp128(fp128)
6597declare fp128 @llvm.log.fp128(fp128)
6598declare fp128 @llvm.log10.fp128(fp128)
6599declare fp128 @llvm.log2.fp128(fp128)
6600declare half @llvm.exp.f16(half)
6601declare half @llvm.exp2.f16(half)
6602declare half @llvm.log.f16(half)
6603declare half @llvm.log10.f16(half)
6604declare half @llvm.log2.f16(half)
6605