Debian Codegraph @

modules/lsp-dsp-lib/include/private/dsp/arch/x86/sse/pmath/lramp.h

raw
1 /*
2 * Copyright (C) 2023 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2023 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-dsp-lib
6 * Created on: 1 февр. 2023 г.
7 *
8 * lsp-dsp-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-dsp-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-dsp-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #ifndef PRIVATE_DSP_ARCH_X86_SSE_PMATH_LRAMP_H_
23 #define PRIVATE_DSP_ARCH_X86_SSE_PMATH_LRAMP_H_
24
25 #ifndef PRIVATE_DSP_ARCH_X86_SSE_IMPL
26 #error "This header should not be included directly"
27 #endif /* PRIVATE_DSP_ARCH_X86_SSE_IMPL */
28
29 namespace lsp
30 {
31 namespace sse
32 {
33 IF_ARCH_X86(
34 static const float lramp_const[] __lsp_aligned16 =
35 {
36 0.0f, 1.0f, 2.0f, 3.0f, // Initial values 0..3
37 4.0f, 5.0f, 6.0f, 7.0f, // Initial values 4..7
38 8.0f, 8.0f, 8.0f, 8.0f // Step
39 };
40 )
41
42 void lramp_set1(float *dst, float v1, float v2, size_t count)
43 {
44 float delta = v2 - v1;
45 if (delta == 0.0f)
46 {
47 dsp::fill(dst, v1, count);
48 return;
49 }
50 if (count == 0)
51 return;
52
53 delta /= count;
54 IF_ARCH_X86( size_t off );
55 ARCH_X86_ASM(
56 __ASM_EMIT("xor %[off], %[off]")
57 __ASM_EMIT("movss %[v1], %%xmm6")
58 __ASM_EMIT("movss %[delta], %%xmm7")
59 __ASM_EMIT("movaps 0x00(%[CC]), %%xmm3") // xmm3 = i[0]
60 __ASM_EMIT("movaps 0x10(%[CC]), %%xmm4") // xmm4 = i[1]
61 __ASM_EMIT("movaps 0x20(%[CC]), %%xmm5") // xmm5 = step
62 __ASM_EMIT("shufps $0x00, %%xmm6, %%xmm6") // xmm6 = v1
63 __ASM_EMIT("shufps $0x00, %%xmm7, %%xmm7") // xmm7 = delta
64
65 __ASM_EMIT("sub $8, %[count]")
66 __ASM_EMIT("jb 2f")
67 // 8x blocks
68 __ASM_EMIT("1:")
69 __ASM_EMIT("movaps %%xmm3, %%xmm0") // xmm0 = i[0]
70 __ASM_EMIT("movaps %%xmm4, %%xmm1") // xmm1 = i[1]
71 __ASM_EMIT("mulps %%xmm7, %%xmm0") // xmm0 = i[0]*delta
72 __ASM_EMIT("addps %%xmm5, %%xmm3") // xmm3 = x[0]' = x[0] + step
73 __ASM_EMIT("mulps %%xmm7, %%xmm1") // xmm1 = i[1]*delta
74 __ASM_EMIT("addps %%xmm5, %%xmm4") // xmm4 = x[1]' = x[1] + step
75 __ASM_EMIT("addps %%xmm6, %%xmm0") // xmm0 = v1 + i[0]*delta
76 __ASM_EMIT("addps %%xmm6, %%xmm1") // xmm1 = v1 + i[1]*delta
77 __ASM_EMIT("movups %%xmm0, 0x00(%[dst], %[off])")
78 __ASM_EMIT("movups %%xmm1, 0x10(%[dst], %[off])")
79 __ASM_EMIT("add $0x20, %[off]")
80 __ASM_EMIT("sub $8, %[count]")
81 __ASM_EMIT("jae 1b")
82
83 // 4x block
84 __ASM_EMIT("2:")
85 __ASM_EMIT("add $4, %[count]")
86 __ASM_EMIT("jl 4f")
87 __ASM_EMIT("movaps %%xmm3, %%xmm0") // xmm0 = i[0]
88 __ASM_EMIT("mulps %%xmm7, %%xmm0") // xmm0 = x[0]*delta
89 __ASM_EMIT("movaps %%xmm4, %%xmm3") // xmm3 = x[0]' = x[1]
90 __ASM_EMIT("addps %%xmm6, %%xmm0") // xmm0 = v1 + i[0]*delta
91 __ASM_EMIT("movups %%xmm0, 0x00(%[dst], %[off])")
92 __ASM_EMIT("add $0x10, %[off]")
93 __ASM_EMIT("sub $4, %[count]")
94
95 // 1x blocks
96 __ASM_EMIT("4:")
97 __ASM_EMIT("add $3, %[count]")
98 __ASM_EMIT("jl 6f")
99 __ASM_EMIT("mulps %%xmm7, %%xmm3") // xmm3 = x[0]*delta
100 __ASM_EMIT("addps %%xmm6, %%xmm3") // xmm3 = v1 + i[0]*delta
101 __ASM_EMIT("5:")
102 __ASM_EMIT("movss %%xmm3, 0x00(%[dst], %[off])")
103 __ASM_EMIT("shufps $0x39, %%xmm3, %%xmm3") // shift xmm3
104 __ASM_EMIT("add $0x04, %[off]")
105 __ASM_EMIT("dec %[count]")
106 __ASM_EMIT("jge 5b")
107
108 __ASM_EMIT("6:")
109 : [count] "+r" (count), [off] "=&r" (off)
110 : [dst] "r" (dst),
111 [CC] "r" (lramp_const),
112 [delta] "m" (delta),
113 [v1] "m" (v1)
114 : "cc", "memory",
115 "xmm0", "xmm1", "xmm2", "xmm3",
116 "xmm4", "xmm5", "xmm6", "xmm7"
117 );
118 }
119
120 #define LRAMP_CORE(DST, SRC) \
121 __ASM_EMIT("xor %[off], %[off]") \
122 __ASM_EMIT("movss %[v1], %%xmm6") \
123 __ASM_EMIT("movss %[delta], %%xmm7") \
124 __ASM_EMIT("movaps 0x00(%[CC]), %%xmm4") /* xmm4 = i[0] */ \
125 __ASM_EMIT("movaps 0x10(%[CC]), %%xmm5") /* xmm5 = i[1] */ \
126 __ASM_EMIT("shufps $0x00, %%xmm6, %%xmm6") /* xmm6 = v1 */ \
127 __ASM_EMIT("shufps $0x00, %%xmm7, %%xmm7") /* xmm7 = delta */ \
128 __ASM_EMIT("sub $8, %[count]") \
129 __ASM_EMIT("jb 2f") \
130 /* 8x blocks */ \
131 __ASM_EMIT("1:") \
132 __ASM_EMIT("movaps %%xmm4, %%xmm0") /* xmm0 = i[0] */ \
133 __ASM_EMIT("movaps %%xmm5, %%xmm1") /* xmm1 = i[1] */ \
134 __ASM_EMIT("mulps %%xmm7, %%xmm0") /* xmm0 = i[0]*delta */ \
135 __ASM_EMIT("mulps %%xmm7, %%xmm1") /* xmm1 = i[1]*delta */ \
136 __ASM_EMIT("addps 0x20(%[CC]), %%xmm4") /* xmm4 = x[0]' = x[0] + step */ \
137 __ASM_EMIT("addps 0x20(%[CC]), %%xmm5") /* xmm5 = x[1]' = x[1] + step */ \
138 __ASM_EMIT("movups 0x00(%[" SRC "], %[off]), %%xmm2") /* xmm2 = src[0] */ \
139 __ASM_EMIT("movups 0x10(%[" SRC "], %[off]), %%xmm3") /* xmm3 = src[1] */ \
140 __ASM_EMIT("addps %%xmm6, %%xmm0") /* xmm0 = v1 + i[0]*delta */ \
141 __ASM_EMIT("addps %%xmm6, %%xmm1") /* xmm1 = v1 + i[1]*delta */ \
142 __ASM_EMIT("mulps %%xmm2, %%xmm0") /* xmm0 = src[0] * (v1 + i[0]*delta) */ \
143 __ASM_EMIT("mulps %%xmm3, %%xmm1") /* xmm1 = src[1] * (v1 + i[1]*delta) */ \
144 __ASM_EMIT("movups %%xmm0, 0x00(%[" DST "], %[off])") \
145 __ASM_EMIT("movups %%xmm1, 0x10(%[" DST "], %[off])") \
146 __ASM_EMIT("add $0x20, %[off]") \
147 __ASM_EMIT("sub $8, %[count]") \
148 __ASM_EMIT("jae 1b") \
149 \
150 /* 4x block */ \
151 __ASM_EMIT("2:") \
152 __ASM_EMIT("add $4, %[count]") \
153 __ASM_EMIT("jl 4f") \
154 __ASM_EMIT("movaps %%xmm4, %%xmm0") /* xmm0 = i[0] */ \
155 __ASM_EMIT("mulps %%xmm7, %%xmm0") /* xmm0 = i[0]*delta */ \
156 __ASM_EMIT("movaps %%xmm5, %%xmm4") /* xmm4 = x[0]' = x[0] + step */ \
157 __ASM_EMIT("movups 0x00(%[" SRC "], %[off]), %%xmm2") /* xmm2 = src[0] */ \
158 __ASM_EMIT("addps %%xmm6, %%xmm0") /* xmm0 = v1 + i[0]*delta */ \
159 __ASM_EMIT("mulps %%xmm2, %%xmm0") /* xmm0 = src[0] * (v1 + i[0]*delta) */ \
160 __ASM_EMIT("movups %%xmm0, 0x00(%[" DST "], %[off])") \
161 __ASM_EMIT("add $0x10, %[off]") \
162 __ASM_EMIT("sub $4, %[count]") \
163 \
164 /* 1x blocks */ \
165 __ASM_EMIT("4:") \
166 __ASM_EMIT("add $3, %[count]") \
167 __ASM_EMIT("jl 6f") \
168 __ASM_EMIT("5:") \
169 __ASM_EMIT("movaps %%xmm4, %%xmm0") /* xmm0 = i[0] */ \
170 __ASM_EMIT("mulss %%xmm7, %%xmm0") /* xmm0 = i[0]*delta */ \
171 __ASM_EMIT("shufps $0x39, %%xmm4, %%xmm4") /* shift xmm4 */ \
172 __ASM_EMIT("movss 0x00(%[" SRC "], %[off]), %%xmm2") /* xmm2 = src[0] */ \
173 __ASM_EMIT("addss %%xmm6, %%xmm0") /* xmm0 = v1 + i[0]*delta */ \
174 __ASM_EMIT("mulss %%xmm2, %%xmm0") /* xmm0 = src[0] * (v1 + i[0]*delta) */ \
175 __ASM_EMIT("movss %%xmm0, 0x00(%[" DST "], %[off])") \
176 __ASM_EMIT("add $0x04, %[off]") \
177 __ASM_EMIT("dec %[count]") \
178 __ASM_EMIT("jge 5b") \
179 \
180 __ASM_EMIT("6:")
181
182
183 void lramp1(float *dst, float v1, float v2, size_t count)
184 {
185 float delta = v2 - v1;
186 if (delta == 0.0f)
187 {
188 dsp::mul_k2(dst, v1, count);
189 return;
190 }
191 if (count == 0)
192 return;
193
194 delta /= count;
195 IF_ARCH_X86( size_t off );
196 ARCH_X86_ASM(
197 LRAMP_CORE("dst", "dst")
198 : [count] "+r" (count), [off] "=&r" (off)
199 : [dst] "r" (dst),
200 [CC] "r" (lramp_const),
201 [delta] "m" (delta),
202 [v1] "m" (v1)
203 : "cc", "memory",
204 "xmm0", "xmm1", "xmm2", "xmm3",
205 "xmm4", "xmm5", "xmm6", "xmm7"
206 );
207 }
208
209 void lramp2(float *dst, const float *src, float v1, float v2, size_t count)
210 {
211 float delta = v2 - v1;
212 if (delta == 0.0f)
213 {
214 dsp::mul_k3(dst, src, v1, count);
215 return;
216 }
217 if (count == 0)
218 return;
219
220 delta /= count;
221 IF_ARCH_X86( size_t off );
222 ARCH_X86_ASM(
223 LRAMP_CORE("dst", "src")
224 : [count] "+r" (count), [off] "=&r" (off)
225 : [dst] "r" (dst), [src] "r" (src),
226 [CC] "r" (lramp_const),
227 [delta] "m" (delta),
228 [v1] "m" (v1)
229 : "cc", "memory",
230 "xmm0", "xmm1", "xmm2", "xmm3",
231 "xmm4", "xmm5", "xmm6", "xmm7"
232 );
233 }
234
235 #undef LRAMP_CORE
236
237 #define OP_DSEL(a, b) a
238 #define OP_RSEL(a, b) b
239
240 #define LRAMP_OP3_CORE(DST, A, B, OP, SEL) \
241 __ASM_EMIT("xor %[off], %[off]") \
242 __ASM_EMIT("movss %[v1], %%xmm6") \
243 __ASM_EMIT("movss %[delta], %%xmm7") \
244 __ASM_EMIT("movaps 0x00(%[CC]), %%xmm4") /* xmm4 = i[0] */ \
245 __ASM_EMIT("movaps 0x10(%[CC]), %%xmm5") /* xmm5 = i[1] */ \
246 __ASM_EMIT("shufps $0x00, %%xmm6, %%xmm6") /* xmm6 = v1 */ \
247 __ASM_EMIT("shufps $0x00, %%xmm7, %%xmm7") /* xmm7 = delta */ \
248 __ASM_EMIT("sub $8, %[count]") \
249 __ASM_EMIT("jb 2f") \
250 /* 8x blocks */ \
251 __ASM_EMIT("1:") \
252 __ASM_EMIT("movaps %%xmm4, %%xmm0") /* xmm0 = i[0] */ \
253 __ASM_EMIT("movaps %%xmm5, %%xmm1") /* xmm1 = i[1] */ \
254 __ASM_EMIT("mulps %%xmm7, %%xmm0") /* xmm0 = i[0]*delta */ \
255 __ASM_EMIT("mulps %%xmm7, %%xmm1") /* xmm1 = i[1]*delta */ \
256 __ASM_EMIT("addps 0x20(%[CC]), %%xmm4") /* xmm4 = x[0]' = x[0] + step */ \
257 __ASM_EMIT("addps 0x20(%[CC]), %%xmm5") /* xmm5 = x[1]' = x[1] + step */ \
258 __ASM_EMIT("movups 0x00(%[" B "], %[off]), %%xmm2") /* xmm2 = b[0] */ \
259 __ASM_EMIT("movups 0x10(%[" B "], %[off]), %%xmm3") /* xmm3 = b[1] */ \
260 __ASM_EMIT("addps %%xmm6, %%xmm0") /* xmm0 = v1 + i[0]*delta */ \
261 __ASM_EMIT("addps %%xmm6, %%xmm1") /* xmm1 = v1 + i[1]*delta */ \
262 __ASM_EMIT("mulps %%xmm2, %%xmm0") /* xmm0 = b[0] * (v1 + i[0]*delta) */ \
263 __ASM_EMIT("mulps %%xmm3, %%xmm1") /* xmm1 = b[1] * (v1 + i[1]*delta) */ \
264 __ASM_EMIT("movups 0x00(%[" A "], %[off]), %%xmm2") /* xmm2 = a[0] */ \
265 __ASM_EMIT("movups 0x10(%[" A "], %[off]), %%xmm3") /* xmm3 = b[1] */ \
266 __ASM_EMIT(OP "ps " SEL("%%xmm0, %%xmm2", "%%xmm2, %%xmm0")) /* xmm2 = a[0] OP b[0] * (v1 + i[0]*delta) */ \
267 __ASM_EMIT(OP "ps " SEL("%%xmm1, %%xmm3", "%%xmm3, %%xmm1")) /* xmm2 = a[0] OP b[0] * (v1 + i[0]*delta) */ \
268 __ASM_EMIT("movups " SEL("%%xmm2", "%%xmm0") ", 0x00(%[" DST "], %[off])") \
269 __ASM_EMIT("movups " SEL("%%xmm3", "%%xmm1") ", 0x10(%[" DST "], %[off])") \
270 __ASM_EMIT("add $0x20, %[off]") \
271 __ASM_EMIT("sub $8, %[count]") \
272 __ASM_EMIT("jae 1b") \
273 \
274 /* 4x block */ \
275 __ASM_EMIT("2:") \
276 __ASM_EMIT("add $4, %[count]") \
277 __ASM_EMIT("jl 4f") \
278 __ASM_EMIT("movaps %%xmm4, %%xmm0") /* xmm0 = i[0] */ \
279 __ASM_EMIT("mulps %%xmm7, %%xmm0") /* xmm0 = i[0]*delta */ \
280 __ASM_EMIT("movaps %%xmm5, %%xmm4") /* xmm4 = x[0]' = x[0] + step */ \
281 __ASM_EMIT("movups 0x00(%[" B "], %[off]), %%xmm2") /* xmm2 = b[0] */ \
282 __ASM_EMIT("addps %%xmm6, %%xmm0") /* xmm0 = v1 + i[0]*delta */ \
283 __ASM_EMIT("mulps %%xmm2, %%xmm0") /* xmm0 = b[0] * (v1 + i[0]*delta) */ \
284 __ASM_EMIT("movups 0x00(%[" A "], %[off]), %%xmm2") /* xmm2 = a[0] */ \
285 __ASM_EMIT(OP "ps " SEL("%%xmm0, %%xmm2", "%%xmm2, %%xmm0")) /* xmm2 = a[0] OP b[0] * (v1 + i[0]*delta) */ \
286 __ASM_EMIT("movups " SEL("%%xmm2", "%%xmm0") ", 0x00(%[" DST "], %[off])") \
287 __ASM_EMIT("add $0x10, %[off]") \
288 __ASM_EMIT("sub $4, %[count]") \
289 \
290 /* 1x blocks */ \
291 __ASM_EMIT("4:") \
292 __ASM_EMIT("add $3, %[count]") \
293 __ASM_EMIT("jl 6f") \
294 __ASM_EMIT("5:") \
295 __ASM_EMIT("movaps %%xmm4, %%xmm0") /* xmm0 = i[0] */ \
296 __ASM_EMIT("mulss %%xmm7, %%xmm0") /* xmm0 = i[0]*delta */ \
297 __ASM_EMIT("shufps $0x39, %%xmm4, %%xmm4") /* shift xmm4 */ \
298 __ASM_EMIT("movss 0x00(%[" B "], %[off]), %%xmm2") /* xmm2 = b[0] */ \
299 __ASM_EMIT("addss %%xmm6, %%xmm0") /* xmm0 = v1 + i[0]*delta */ \
300 __ASM_EMIT("mulss %%xmm2, %%xmm0") /* xmm0 = b[0] * (v1 + i[0]*delta) */ \
301 __ASM_EMIT("movss 0x00(%[" A "], %[off]), %%xmm2") /* xmm2 = a[0] */ \
302 __ASM_EMIT(OP "ss " SEL("%%xmm0, %%xmm2", "%%xmm2, %%xmm0")) /* xmm2 = a[0] OP b[0] * (v1 + i[0]*delta) */ \
303 __ASM_EMIT("movss " SEL("%%xmm2", "%%xmm0") ", 0x00(%[" DST "], %[off])") \
304 __ASM_EMIT("add $0x04, %[off]") \
305 __ASM_EMIT("dec %[count]") \
306 __ASM_EMIT("jge 5b") \
307 \
308 __ASM_EMIT("6:")
309
310 void lramp_add2(float *dst, const float *src, float v1, float v2, size_t count)
311 {
312 float delta = v2 - v1;
313 if (delta == 0.0f)
314 {
315 dsp::fmadd_k3(dst, src, v1, count);
316 return;
317 }
318 if (count == 0)
319 return;
320
321 delta /= count;
322 IF_ARCH_X86( size_t off );
323 ARCH_X86_ASM(
324 LRAMP_OP3_CORE("dst", "dst", "src", "add", OP_DSEL)
325 : [count] "+r" (count), [off] "=&r" (off)
326 : [dst] "r" (dst), [src] "r" (src),
327 [CC] "r" (lramp_const),
328 [delta] "m" (delta),
329 [v1] "m" (v1)
330 : "cc", "memory",
331 "xmm0", "xmm1", "xmm2", "xmm3",
332 "xmm4", "xmm5", "xmm6", "xmm7"
333 );
334 }
335
336 void lramp_sub2(float *dst, const float *src, float v1, float v2, size_t count)
337 {
338 float delta = v2 - v1;
339 if (delta == 0.0f)
340 {
341 dsp::fmsub_k3(dst, src, v1, count);
342 return;
343 }
344 if (count == 0)
345 return;
346
347 delta /= count;
348 IF_ARCH_X86( size_t off );
349 ARCH_X86_ASM(
350 LRAMP_OP3_CORE("dst", "dst", "src", "sub", OP_DSEL)
351 : [count] "+r" (count), [off] "=&r" (off)
352 : [dst] "r" (dst), [src] "r" (src),
353 [CC] "r" (lramp_const),
354 [delta] "m" (delta),
355 [v1] "m" (v1)
356 : "cc", "memory",
357 "xmm0", "xmm1", "xmm2", "xmm3",
358 "xmm4", "xmm5", "xmm6", "xmm7"
359 );
360 }
361
362 void lramp_rsub2(float *dst, const float *src, float v1, float v2, size_t count)
363 {
364 float delta = v2 - v1;
365 if (delta == 0.0f)
366 {
367 dsp::fmrsub_k3(dst, src, v1, count);
368 return;
369 }
370 if (count == 0)
371 return;
372
373 delta /= count;
374 IF_ARCH_X86( size_t off );
375 ARCH_X86_ASM(
376 LRAMP_OP3_CORE("dst", "dst", "src", "sub", OP_RSEL)
377 : [count] "+r" (count), [off] "=&r" (off)
378 : [dst] "r" (dst), [src] "r" (src),
379 [CC] "r" (lramp_const),
380 [delta] "m" (delta),
381 [v1] "m" (v1)
382 : "cc", "memory",
383 "xmm0", "xmm1", "xmm2", "xmm3",
384 "xmm4", "xmm5", "xmm6", "xmm7"
385 );
386 }
387
388 void lramp_mul2(float *dst, const float *src, float v1, float v2, size_t count)
389 {
390 float delta = v2 - v1;
391 if (delta == 0.0f)
392 {
393 dsp::fmmul_k3(dst, src, v1, count);
394 return;
395 }
396 if (count == 0)
397 return;
398
399 delta /= count;
400 IF_ARCH_X86( size_t off );
401 ARCH_X86_ASM(
402 LRAMP_OP3_CORE("dst", "dst", "src", "mul", OP_DSEL)
403 : [count] "+r" (count), [off] "=&r" (off)
404 : [dst] "r" (dst), [src] "r" (src),
405 [CC] "r" (lramp_const),
406 [delta] "m" (delta),
407 [v1] "m" (v1)
408 : "cc", "memory",
409 "xmm0", "xmm1", "xmm2", "xmm3",
410 "xmm4", "xmm5", "xmm6", "xmm7"
411 );
412 }
413
414 void lramp_div2(float *dst, const float *src, float v1, float v2, size_t count)
415 {
416 float delta = v2 - v1;
417 if (delta == 0.0f)
418 {
419 dsp::fmdiv_k3(dst, src, v1, count);
420 return;
421 }
422 if (count == 0)
423 return;
424
425 delta /= count;
426 IF_ARCH_X86( size_t off );
427 ARCH_X86_ASM(
428 LRAMP_OP3_CORE("dst", "dst", "src", "div", OP_DSEL)
429 : [count] "+r" (count), [off] "=&r" (off)
430 : [dst] "r" (dst), [src] "r" (src),
431 [CC] "r" (lramp_const),
432 [delta] "m" (delta),
433 [v1] "m" (v1)
434 : "cc", "memory",
435 "xmm0", "xmm1", "xmm2", "xmm3",
436 "xmm4", "xmm5", "xmm6", "xmm7"
437 );
438 }
439
440 void lramp_rdiv2(float *dst, const float *src, float v1, float v2, size_t count)
441 {
442 float delta = v2 - v1;
443 if (delta == 0.0f)
444 {
445 dsp::fmrdiv_k3(dst, src, v1, count);
446 return;
447 }
448 if (count == 0)
449 return;
450
451 delta /= count;
452 IF_ARCH_X86( size_t off );
453 ARCH_X86_ASM(
454 LRAMP_OP3_CORE("dst", "dst", "src", "div", OP_RSEL)
455 : [count] "+r" (count), [off] "=&r" (off)
456 : [dst] "r" (dst), [src] "r" (src),
457 [CC] "r" (lramp_const),
458 [delta] "m" (delta),
459 [v1] "m" (v1)
460 : "cc", "memory",
461 "xmm0", "xmm1", "xmm2", "xmm3",
462 "xmm4", "xmm5", "xmm6", "xmm7"
463 );
464 }
465
466 void lramp_add3(float *dst, const float *a, const float *b, float v1, float v2, size_t count)
467 {
468 float delta = v2 - v1;
469 if (delta == 0.0f)
470 {
471 dsp::fmadd_k4(dst, a, b, v1, count);
472 return;
473 }
474 if (count == 0)
475 return;
476
477 delta /= count;
478 IF_ARCH_X86( size_t off );
479 ARCH_X86_ASM(
480 LRAMP_OP3_CORE("dst", "a", "b", "add", OP_DSEL)
481 : [off] "=&r" (off),
482 __IF_32([count] "+g" (count))
483 __IF_64([count] "+r" (count))
484 : [dst] "r" (dst), [a] "r" (a), [b] "r" (b),
485 [CC] "r" (lramp_const),
486 [delta] "m" (delta),
487 [v1] "m" (v1)
488 : "cc", "memory",
489 "xmm0", "xmm1", "xmm2", "xmm3",
490 "xmm4", "xmm5", "xmm6", "xmm7"
491 );
492 }
493
494 void lramp_sub3(float *dst, const float *a, const float *b, float v1, float v2, size_t count)
495 {
496 float delta = v2 - v1;
497 if (delta == 0.0f)
498 {
499 dsp::fmsub_k4(dst, a, b, v1, count);
500 return;
501 }
502 if (count == 0)
503 return;
504
505 delta /= count;
506 IF_ARCH_X86( size_t off );
507 ARCH_X86_ASM(
508 LRAMP_OP3_CORE("dst", "a", "b", "sub", OP_DSEL)
509 : [off] "=&r" (off),
510 __IF_32([count] "+g" (count))
511 __IF_64([count] "+r" (count))
512 : [dst] "r" (dst), [a] "r" (a), [b] "r" (b),
513 [CC] "r" (lramp_const),
514 [delta] "m" (delta),
515 [v1] "m" (v1)
516 : "cc", "memory",
517 "xmm0", "xmm1", "xmm2", "xmm3",
518 "xmm4", "xmm5", "xmm6", "xmm7"
519 );
520 }
521
522 void lramp_rsub3(float *dst, const float *a, const float *b, float v1, float v2, size_t count)
523 {
524 float delta = v2 - v1;
525 if (delta == 0.0f)
526 {
527 dsp::fmrsub_k4(dst, a, b, v1, count);
528 return;
529 }
530 if (count == 0)
531 return;
532
533 delta /= count;
534 IF_ARCH_X86( size_t off );
535 ARCH_X86_ASM(
536 LRAMP_OP3_CORE("dst", "a", "b", "sub", OP_RSEL)
537 : [off] "=&r" (off),
538 __IF_32([count] "+g" (count))
539 __IF_64([count] "+r" (count))
540 : [dst] "r" (dst), [a] "r" (a), [b] "r" (b),
541 [CC] "r" (lramp_const),
542 [delta] "m" (delta),
543 [v1] "m" (v1)
544 : "cc", "memory",
545 "xmm0", "xmm1", "xmm2", "xmm3",
546 "xmm4", "xmm5", "xmm6", "xmm7"
547 );
548 }
549
550 void lramp_mul3(float *dst, const float *a, const float *b, float v1, float v2, size_t count)
551 {
552 float delta = v2 - v1;
553 if (delta == 0.0f)
554 {
555 dsp::fmmul_k4(dst, a, b, v1, count);
556 return;
557 }
558 if (count == 0)
559 return;
560
561 delta /= count;
562 IF_ARCH_X86( size_t off );
563 ARCH_X86_ASM(
564 LRAMP_OP3_CORE("dst", "a", "b", "mul", OP_DSEL)
565 : [off] "=&r" (off),
566 __IF_32([count] "+g" (count))
567 __IF_64([count] "+r" (count))
568 : [dst] "r" (dst), [a] "r" (a), [b] "r" (b),
569 [CC] "r" (lramp_const),
570 [delta] "m" (delta),
571 [v1] "m" (v1)
572 : "cc", "memory",
573 "xmm0", "xmm1", "xmm2", "xmm3",
574 "xmm4", "xmm5", "xmm6", "xmm7"
575 );
576 }
577
578 void lramp_div3(float *dst, const float *a, const float *b, float v1, float v2, size_t count)
579 {
580 float delta = v2 - v1;
581 if (delta == 0.0f)
582 {
583 dsp::fmdiv_k4(dst, a, b, v1, count);
584 return;
585 }
586 if (count == 0)
587 return;
588
589 delta /= count;
590 IF_ARCH_X86( size_t off );
591 ARCH_X86_ASM(
592 LRAMP_OP3_CORE("dst", "a", "b", "div", OP_DSEL)
593 : [off] "=&r" (off),
594 __IF_32([count] "+g" (count))
595 __IF_64([count] "+r" (count))
596 : [dst] "r" (dst), [a] "r" (a), [b] "r" (b),
597 [CC] "r" (lramp_const),
598 [delta] "m" (delta),
599 [v1] "m" (v1)
600 : "cc", "memory",
601 "xmm0", "xmm1", "xmm2", "xmm3",
602 "xmm4", "xmm5", "xmm6", "xmm7"
603 );
604 }
605
606 void lramp_rdiv3(float *dst, const float *a, const float *b, float v1, float v2, size_t count)
607 {
608 float delta = v2 - v1;
609 if (delta == 0.0f)
610 {
611 dsp::fmrdiv_k4(dst, a, b, v1, count);
612 return;
613 }
614 if (count == 0)
615 return;
616
617 delta /= count;
618 IF_ARCH_X86( size_t off );
619 ARCH_X86_ASM(
620 LRAMP_OP3_CORE("dst", "a", "b", "div", OP_RSEL)
621 : [off] "=&r" (off),
622 __IF_32([count] "+g" (count))
623 __IF_64([count] "+r" (count))
624 : [dst] "r" (dst), [a] "r" (a), [b] "r" (b),
625 [CC] "r" (lramp_const),
626 [delta] "m" (delta),
627 [v1] "m" (v1)
628 : "cc", "memory",
629 "xmm0", "xmm1", "xmm2", "xmm3",
630 "xmm4", "xmm5", "xmm6", "xmm7"
631 );
632 }
633
634 #undef LRAMP_OP3_CORE
635 #undef OP_DSEL
636 #undef OP_RSEL
637
638 } /* namespace sse */
639 } /* namespace lsp */
640
641
642
643 #endif /* PRIVATE_DSP_ARCH_X86_SSE_PMATH_LRAMP_H_ */