Debian Codegraph @

modules/lsp-dsp-lib/include/private/dsp/arch/x86/sse2/pmath/log.h

raw
1 /*
2 * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2025 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-dsp-lib
6 * Created on: 31 мар. 2020 г.
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_SSE2_PMATH_LOG_H_
23 #define PRIVATE_DSP_ARCH_X86_SSE2_PMATH_LOG_H_
24
25 #ifndef PRIVATE_DSP_ARCH_X86_SSE2_IMPL
26 #error "This header should not be included directly"
27 #endif /* PRIVATE_DSP_ARCH_X86_SSE2_IMPL */
28
29 namespace lsp
30 {
31 namespace sse2
32 {
33 IF_ARCH_X86(
34 static const uint32_t LOG2_CONST[] __lsp_aligned16 =
35 {
36 LSP_DSP_VEC4(0x007fffff), // frac
37 LSP_DSP_VEC4(0x3f800000), // 1.0f
38 LSP_DSP_VEC4(0x0000007f), // 127
39 LSP_DSP_VEC4(0x3dba2e8c), // C0 = 1/11 = 0.0909090936183929
40 LSP_DSP_VEC4(0x3de38e39), // C1 = 1/9 = 0.1111111119389534
41 LSP_DSP_VEC4(0x3e124925), // C2 = 1/7 = 0.1428571492433548
42 LSP_DSP_VEC4(0x3e4ccccd), // C3 = 1/5 = 0.2000000029802322
43 LSP_DSP_VEC4(0x3eaaaaab), // C4 = 1/3 = 0.3333333432674408
44 LSP_DSP_VEC4(0x3f800000) // C5 = 1/1 = 1.0000000000000000
45 };
46
47 static const float LOGB_C[] __lsp_aligned16 =
48 {
49 LSP_DSP_VEC4(2.0f * float(M_LOG2E))
50 };
51
52 static const float LOGE_C[] __lsp_aligned16 =
53 {
54 LSP_DSP_VEC4(1.0f / float(M_LOG2E))
55 };
56
57 static const float LOGD_C[] __lsp_aligned16 =
58 {
59 LSP_DSP_VEC4(2.0f * float(M_LOG10E)),
60 LSP_DSP_VEC4(0.301029995663981f) // 1/log2(10)
61 };
62 )
63
64 #define LOGN_CORE_X8 \
65 /* xmm0 = x */ \
66 __ASM_EMIT("movdqa %%xmm0, %%xmm1") /* xmm1 = x */ \
67 __ASM_EMIT("movdqa %%xmm4, %%xmm5") \
68 __ASM_EMIT("pand 0x00 + %[L2C], %%xmm0") /* xmm0 = x & F_MASK */ \
69 __ASM_EMIT("pand 0x00 + %[L2C], %%xmm4") \
70 __ASM_EMIT("psrld $23, %%xmm1") /* xmm1 = ilog2(x) + 127 */ \
71 __ASM_EMIT("psrld $23, %%xmm5") \
72 __ASM_EMIT("por 0x10 + %[L2C], %%xmm0") /* xmm0 = X = (x & F_MASK) | 1.0f */ \
73 __ASM_EMIT("por 0x10 + %[L2C], %%xmm4") \
74 __ASM_EMIT("psubd 0x20 + %[L2C], %%xmm1") /* xmm1 = r = ilog2(x) */ \
75 __ASM_EMIT("psubd 0x20 + %[L2C], %%xmm5") \
76 __ASM_EMIT("movaps %%xmm0, %%xmm2") /* xmm2 = X */ \
77 __ASM_EMIT("movaps %%xmm4, %%xmm6") \
78 __ASM_EMIT("cvtdq2ps %%xmm1, %%xmm1") /* xmm1 = R = float(r) */ \
79 __ASM_EMIT("cvtdq2ps %%xmm5, %%xmm5") \
80 __ASM_EMIT("subps 0x10 + %[L2C], %%xmm0") /* xmm0 = X - 1 */ \
81 __ASM_EMIT("subps 0x10 + %[L2C], %%xmm4") \
82 __ASM_EMIT("addps 0x10 + %[L2C], %%xmm2") /* xmm2 = X + 1 */ \
83 __ASM_EMIT("addps 0x10 + %[L2C], %%xmm6") \
84 __ASM_EMIT("divps %%xmm2, %%xmm0") /* xmm0 = y = (X-1)/(X+1) */ \
85 __ASM_EMIT("divps %%xmm6, %%xmm4") \
86 __ASM_EMIT("movaps %%xmm0, %%xmm2") /* xmm2 = y */ \
87 __ASM_EMIT("movaps %%xmm4, %%xmm6") \
88 __ASM_EMIT("movaps 0x30 + %[L2C], %%xmm3") /* xmm3 = C0 */ \
89 __ASM_EMIT("movaps 0x30 + %[L2C], %%xmm7") \
90 __ASM_EMIT("mulps %%xmm2, %%xmm2") /* xmm2 = Y = y*y */ \
91 __ASM_EMIT("mulps %%xmm6, %%xmm6") \
92 /* xmm0 = y, xmm1 = R, xmm2 = Y */ \
93 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = C0*Y */ \
94 __ASM_EMIT("mulps %%xmm6, %%xmm7") \
95 __ASM_EMIT("addps 0x40 + %[L2C], %%xmm3") /* xmm3 = C1+C0*Y */ \
96 __ASM_EMIT("addps 0x40 + %[L2C], %%xmm7") \
97 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = Y*(C1+C0*Y) */ \
98 __ASM_EMIT("mulps %%xmm6, %%xmm7") \
99 __ASM_EMIT("addps 0x50 + %[L2C], %%xmm3") /* xmm3 = C2+Y*(C1+C0*Y) */ \
100 __ASM_EMIT("addps 0x50 + %[L2C], %%xmm7") \
101 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = Y*(C2+Y*(C1+C0*Y)) */ \
102 __ASM_EMIT("mulps %%xmm6, %%xmm7") \
103 __ASM_EMIT("addps 0x60 + %[L2C], %%xmm3") /* xmm3 = C3+Y*(C2+Y*(C1+C0*Y)) */ \
104 __ASM_EMIT("addps 0x60 + %[L2C], %%xmm7") \
105 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = Y*(C3+Y*(C2+Y*(C1+C0*Y))) */ \
106 __ASM_EMIT("mulps %%xmm6, %%xmm7") \
107 __ASM_EMIT("addps 0x70 + %[L2C], %%xmm3") /* xmm3 = C4+Y*(C3+Y*(C2+Y*(C1+C0*Y))) */ \
108 __ASM_EMIT("addps 0x70 + %[L2C], %%xmm7") \
109 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = Y*(C4+Y*(C3+Y*(C2+Y*(C1+C0*Y)))) */ \
110 __ASM_EMIT("mulps %%xmm6, %%xmm7") \
111 __ASM_EMIT("addps 0x80 + %[L2C], %%xmm3") /* xmm3 = C5+Y*(C4+Y*(C3+Y*(C2+Y*(C1+C0*Y)))) */ \
112 __ASM_EMIT("addps 0x80 + %[L2C], %%xmm7") \
113 __ASM_EMIT("mulps %%xmm3, %%xmm0") /* xmm0 = y*(C5+Y*(C4+Y*(C3+Y*(C2+Y*(C1+C0*Y))))) */ \
114 __ASM_EMIT("mulps %%xmm7, %%xmm4") \
115 /* xmm0 = y*L, xmm1 = R */
116
117 #define LOGN_CORE_X4 \
118 /* xmm0 = x */ \
119 __ASM_EMIT("movdqa %%xmm0, %%xmm1") /* xmm1 = x */ \
120 __ASM_EMIT("pand 0x00 + %[L2C], %%xmm0") /* xmm0 = x & F_MASK */ \
121 __ASM_EMIT("psrld $23, %%xmm1") /* xmm1 = ilog2(x) + 127 */ \
122 __ASM_EMIT("por 0x10 + %[L2C], %%xmm0") /* xmm0 = X = (x & F_MASK) | 1.0f */ \
123 __ASM_EMIT("psubd 0x20 + %[L2C], %%xmm1") /* xmm1 = r = ilog2(x) */ \
124 __ASM_EMIT("movaps %%xmm0, %%xmm2") /* xmm2 = X */ \
125 __ASM_EMIT("cvtdq2ps %%xmm1, %%xmm1") /* xmm1 = R = float(r) */ \
126 __ASM_EMIT("subps 0x10 + %[L2C], %%xmm0") /* xmm0 = X - 1 */ \
127 __ASM_EMIT("addps 0x10 + %[L2C], %%xmm2") /* xmm2 = X + 1 */ \
128 __ASM_EMIT("divps %%xmm2, %%xmm0") /* xmm0 = y = (X-1)/(X+1) */ \
129 __ASM_EMIT("movaps %%xmm0, %%xmm2") /* xmm2 = y */ \
130 __ASM_EMIT("movaps 0x30 + %[L2C], %%xmm3") /* xmm3 = C0 */ \
131 __ASM_EMIT("mulps %%xmm2, %%xmm2") /* xmm2 = Y = y*y */ \
132 /* xmm0 = y, xmm1 = R, xmm2 = Y */ \
133 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = C0*Y */ \
134 __ASM_EMIT("addps 0x40 + %[L2C], %%xmm3") /* xmm3 = C1+C0*Y */ \
135 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = Y*(C1+C0*Y) */ \
136 __ASM_EMIT("addps 0x50 + %[L2C], %%xmm3") /* xmm3 = C2+Y*(C1+C0*Y) */ \
137 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = Y*(C2+Y*(C1+C0*Y)) */ \
138 __ASM_EMIT("addps 0x60 + %[L2C], %%xmm3") /* xmm3 = C3+Y*(C2+Y*(C1+C0*Y)) */ \
139 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = Y*(C3+Y*(C2+Y*(C1+C0*Y))) */ \
140 __ASM_EMIT("addps 0x70 + %[L2C], %%xmm3") /* xmm3 = C4+Y*(C3+Y*(C2+Y*(C1+C0*Y))) */ \
141 __ASM_EMIT("mulps %%xmm2, %%xmm3") /* xmm3 = Y*(C4+Y*(C3+Y*(C2+Y*(C1+C0*Y)))) */ \
142 __ASM_EMIT("addps 0x80 + %[L2C], %%xmm3") /* xmm3 = C5+Y*(C4+Y*(C3+Y*(C2+Y*(C1+C0*Y)))) */ \
143 __ASM_EMIT("mulps %%xmm3, %%xmm0") /* xmm0 = y*(C5+Y*(C4+Y*(C3+Y*(C2+Y*(C1+C0*Y))))) */ \
144 /* xmm0 = y*L, xmm1 = R */
145
146 #define LOGB_CORE_X8 \
147 LOGN_CORE_X8 \
148 __ASM_EMIT("mulps 0x00 + %[LOGC], %%xmm0") \
149 __ASM_EMIT("mulps 0x00 + %[LOGC], %%xmm4") \
150 __ASM_EMIT("addps %%xmm1, %%xmm0") \
151 __ASM_EMIT("addps %%xmm5, %%xmm4")
152
153 #define LOGB_CORE_X4 \
154 LOGN_CORE_X4 \
155 __ASM_EMIT("mulps 0x00 + %[LOGC], %%xmm0") \
156 __ASM_EMIT("addps %%xmm1, %%xmm0")
157
158 #define LOGE_CORE_X8 \
159 LOGN_CORE_X8 \
160 __ASM_EMIT("addps %%xmm0, %%xmm0") \
161 __ASM_EMIT("addps %%xmm4, %%xmm4") \
162 __ASM_EMIT("mulps 0x00 + %[LOGC], %%xmm1") \
163 __ASM_EMIT("mulps 0x00 + %[LOGC], %%xmm5") \
164 __ASM_EMIT("addps %%xmm1, %%xmm0") \
165 __ASM_EMIT("addps %%xmm5, %%xmm4")
166
167 #define LOGE_CORE_X4 \
168 LOGN_CORE_X4 \
169 __ASM_EMIT("addps %%xmm0, %%xmm0") \
170 __ASM_EMIT("mulps 0x00 + %[LOGC], %%xmm1") \
171 __ASM_EMIT("addps %%xmm1, %%xmm0")
172
173 #define LOGD_CORE_X8 \
174 LOGN_CORE_X8 \
175 __ASM_EMIT("mulps 0x00 + %[LOGC], %%xmm0") \
176 __ASM_EMIT("mulps 0x00 + %[LOGC], %%xmm4") \
177 __ASM_EMIT("mulps 0x10 + %[LOGC], %%xmm1") \
178 __ASM_EMIT("mulps 0x10 + %[LOGC], %%xmm5") \
179 __ASM_EMIT("addps %%xmm1, %%xmm0") \
180 __ASM_EMIT("addps %%xmm5, %%xmm4")
181
182 #define LOGD_CORE_X4 \
183 LOGN_CORE_X4 \
184 __ASM_EMIT("mulps 0x00 + %[LOGC], %%xmm0") \
185 __ASM_EMIT("mulps 0x10 + %[LOGC], %%xmm1") \
186 __ASM_EMIT("addps %%xmm1, %%xmm0")
187
188 void logb2(float *dst, const float *src, size_t count)
189 {
190 ARCH_X86_ASM(
191 // x8 blocks
192 __ASM_EMIT("sub $8, %[count]")
193 __ASM_EMIT("jb 2f")
194 __ASM_EMIT("1:")
195 __ASM_EMIT("movups 0x00(%[src]), %%xmm0")
196 __ASM_EMIT("movups 0x10(%[src]), %%xmm4")
197 LOGB_CORE_X8
198 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
199 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])")
200 __ASM_EMIT("add $0x20, %[src]")
201 __ASM_EMIT("add $0x20, %[dst]")
202 __ASM_EMIT("sub $8, %[count]")
203 __ASM_EMIT("jae 1b")
204 __ASM_EMIT("2:")
205 // x4 block
206 __ASM_EMIT("add $4, %[count]")
207 __ASM_EMIT("jl 4f")
208 __ASM_EMIT("movups 0x00(%[src]), %%xmm0")
209 LOGB_CORE_X4
210 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
211 __ASM_EMIT("add $0x10, %[src]")
212 __ASM_EMIT("add $0x10, %[dst]")
213 __ASM_EMIT("sub $4, %[count]")
214 __ASM_EMIT("4:")
215 // Tail: 1x-3x block
216 __ASM_EMIT("add $4, %[count]")
217 __ASM_EMIT("jle 12f")
218 __ASM_EMIT("test $1, %[count]")
219 __ASM_EMIT("jz 6f")
220 __ASM_EMIT("movss 0x00(%[src]), %%xmm0")
221 __ASM_EMIT("add $4, %[src]")
222 __ASM_EMIT("6:")
223 __ASM_EMIT("test $2, %[count]")
224 __ASM_EMIT("jz 8f")
225 __ASM_EMIT("movhps 0x00(%[src]), %%xmm0")
226 __ASM_EMIT("8:")
227 LOGB_CORE_X4
228 __ASM_EMIT("test $1, %[count]")
229 __ASM_EMIT("jz 10f")
230 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
231 __ASM_EMIT("add $4, %[dst]")
232 __ASM_EMIT("10:")
233 __ASM_EMIT("test $2, %[count]")
234 __ASM_EMIT("jz 12f")
235 __ASM_EMIT("movhps %%xmm0, 0x00(%[dst])")
236 __ASM_EMIT("12:")
237
238 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
239 : [L2C] "o" (LOG2_CONST),
240 [LOGC] "o" (LOGB_C)
241 : "cc", "memory",
242 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
243 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
244 );
245 }
246
247 void logb1(float *dst, size_t count)
248 {
249 IF_ARCH_X86(float *src);
250
251 ARCH_X86_ASM(
252 // x8 blocks
253 __ASM_EMIT("sub $8, %[count]")
254 __ASM_EMIT("jb 2f")
255 __ASM_EMIT("1:")
256 __ASM_EMIT("movups 0x00(%[dst]), %%xmm0")
257 __ASM_EMIT("movups 0x10(%[dst]), %%xmm4")
258 LOGB_CORE_X8
259 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
260 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])")
261 __ASM_EMIT("add $0x20, %[dst]")
262 __ASM_EMIT("sub $8, %[count]")
263 __ASM_EMIT("jae 1b")
264 __ASM_EMIT("2:")
265 // x4 block
266 __ASM_EMIT("add $4, %[count]")
267 __ASM_EMIT("jl 4f")
268 __ASM_EMIT("movups 0x00(%[dst]), %%xmm0")
269 LOGB_CORE_X4
270 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
271 __ASM_EMIT("add $0x10, %[dst]")
272 __ASM_EMIT("sub $4, %[count]")
273 __ASM_EMIT("4:")
274 // Tail: 1x-3x block
275 __ASM_EMIT("add $4, %[count]")
276 __ASM_EMIT("jle 12f")
277 __ASM_EMIT("mov %[dst], %[src]")
278 __ASM_EMIT("test $1, %[count]")
279 __ASM_EMIT("jz 6f")
280 __ASM_EMIT("movss 0x00(%[src]), %%xmm0")
281 __ASM_EMIT("add $4, %[src]")
282 __ASM_EMIT("6:")
283 __ASM_EMIT("test $2, %[count]")
284 __ASM_EMIT("jz 8f")
285 __ASM_EMIT("movhps 0x00(%[src]), %%xmm0")
286 __ASM_EMIT("8:")
287 LOGB_CORE_X4
288 __ASM_EMIT("test $1, %[count]")
289 __ASM_EMIT("jz 10f")
290 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
291 __ASM_EMIT("add $4, %[dst]")
292 __ASM_EMIT("10:")
293 __ASM_EMIT("test $2, %[count]")
294 __ASM_EMIT("jz 12f")
295 __ASM_EMIT("movhps %%xmm0, 0x00(%[dst])")
296 __ASM_EMIT("12:")
297
298 : [dst] "+r" (dst), [src] "=&r" (src), [count] "+r" (count)
299 : [L2C] "o" (LOG2_CONST),
300 [LOGC] "o" (LOGB_C)
301 : "cc", "memory",
302 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
303 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
304 );
305 }
306
307 void loge2(float *dst, const float *src, size_t count)
308 {
309 ARCH_X86_ASM(
310 // x8 blocks
311 __ASM_EMIT("sub $8, %[count]")
312 __ASM_EMIT("jb 2f")
313 __ASM_EMIT("1:")
314 __ASM_EMIT("movups 0x00(%[src]), %%xmm0")
315 __ASM_EMIT("movups 0x10(%[src]), %%xmm4")
316 LOGE_CORE_X8
317 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
318 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])")
319 __ASM_EMIT("add $0x20, %[src]")
320 __ASM_EMIT("add $0x20, %[dst]")
321 __ASM_EMIT("sub $8, %[count]")
322 __ASM_EMIT("jae 1b")
323 __ASM_EMIT("2:")
324 // x4 block
325 __ASM_EMIT("add $4, %[count]")
326 __ASM_EMIT("jl 4f")
327 __ASM_EMIT("movups 0x00(%[src]), %%xmm0")
328 LOGE_CORE_X4
329 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
330 __ASM_EMIT("add $0x10, %[src]")
331 __ASM_EMIT("add $0x10, %[dst]")
332 __ASM_EMIT("sub $4, %[count]")
333 __ASM_EMIT("4:")
334 // Tail: 1x-3x block
335 __ASM_EMIT("add $4, %[count]")
336 __ASM_EMIT("jle 12f")
337 __ASM_EMIT("test $1, %[count]")
338 __ASM_EMIT("jz 6f")
339 __ASM_EMIT("movss 0x00(%[src]), %%xmm0")
340 __ASM_EMIT("add $4, %[src]")
341 __ASM_EMIT("6:")
342 __ASM_EMIT("test $2, %[count]")
343 __ASM_EMIT("jz 8f")
344 __ASM_EMIT("movhps 0x00(%[src]), %%xmm0")
345 __ASM_EMIT("8:")
346 LOGE_CORE_X4
347 __ASM_EMIT("test $1, %[count]")
348 __ASM_EMIT("jz 10f")
349 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
350 __ASM_EMIT("add $4, %[dst]")
351 __ASM_EMIT("10:")
352 __ASM_EMIT("test $2, %[count]")
353 __ASM_EMIT("jz 12f")
354 __ASM_EMIT("movhps %%xmm0, 0x00(%[dst])")
355 __ASM_EMIT("12:")
356
357 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
358 : [L2C] "o" (LOG2_CONST),
359 [LOGC] "o" (LOGE_C)
360 : "cc", "memory",
361 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
362 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
363 );
364 }
365
366 void loge1(float *dst, size_t count)
367 {
368 IF_ARCH_X86(float *src);
369
370 ARCH_X86_ASM(
371 // x8 blocks
372 __ASM_EMIT("sub $8, %[count]")
373 __ASM_EMIT("jb 2f")
374 __ASM_EMIT("1:")
375 __ASM_EMIT("movups 0x00(%[dst]), %%xmm0")
376 __ASM_EMIT("movups 0x10(%[dst]), %%xmm4")
377 LOGE_CORE_X8
378 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
379 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])")
380 __ASM_EMIT("add $0x20, %[dst]")
381 __ASM_EMIT("sub $8, %[count]")
382 __ASM_EMIT("jae 1b")
383 __ASM_EMIT("2:")
384 // x4 block
385 __ASM_EMIT("add $4, %[count]")
386 __ASM_EMIT("jl 4f")
387 __ASM_EMIT("movups 0x00(%[dst]), %%xmm0")
388 LOGE_CORE_X4
389 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
390 __ASM_EMIT("add $0x10, %[dst]")
391 __ASM_EMIT("sub $4, %[count]")
392 __ASM_EMIT("4:")
393 // Tail: 1x-3x block
394 __ASM_EMIT("add $4, %[count]")
395 __ASM_EMIT("jle 12f")
396 __ASM_EMIT("mov %[dst], %[src]")
397 __ASM_EMIT("test $1, %[count]")
398 __ASM_EMIT("jz 6f")
399 __ASM_EMIT("movss 0x00(%[src]), %%xmm0")
400 __ASM_EMIT("add $4, %[src]")
401 __ASM_EMIT("6:")
402 __ASM_EMIT("test $2, %[count]")
403 __ASM_EMIT("jz 8f")
404 __ASM_EMIT("movhps 0x00(%[src]), %%xmm0")
405 __ASM_EMIT("8:")
406 LOGE_CORE_X4
407 __ASM_EMIT("test $1, %[count]")
408 __ASM_EMIT("jz 10f")
409 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
410 __ASM_EMIT("add $4, %[dst]")
411 __ASM_EMIT("10:")
412 __ASM_EMIT("test $2, %[count]")
413 __ASM_EMIT("jz 12f")
414 __ASM_EMIT("movhps %%xmm0, 0x00(%[dst])")
415 __ASM_EMIT("12:")
416
417 : [dst] "+r" (dst), [src] "=&r" (src), [count] "+r" (count)
418 : [L2C] "o" (LOG2_CONST),
419 [LOGC] "o" (LOGE_C)
420 : "cc", "memory",
421 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
422 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
423 );
424 }
425
426 void logd2(float *dst, const float *src, size_t count)
427 {
428 ARCH_X86_ASM(
429 // x8 blocks
430 __ASM_EMIT("sub $8, %[count]")
431 __ASM_EMIT("jb 2f")
432 __ASM_EMIT("1:")
433 __ASM_EMIT("movups 0x00(%[src]), %%xmm0")
434 __ASM_EMIT("movups 0x10(%[src]), %%xmm4")
435 LOGD_CORE_X8
436 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
437 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])")
438 __ASM_EMIT("add $0x20, %[src]")
439 __ASM_EMIT("add $0x20, %[dst]")
440 __ASM_EMIT("sub $8, %[count]")
441 __ASM_EMIT("jae 1b")
442 __ASM_EMIT("2:")
443 // x4 block
444 __ASM_EMIT("add $4, %[count]")
445 __ASM_EMIT("jl 4f")
446 __ASM_EMIT("movups 0x00(%[src]), %%xmm0")
447 LOGD_CORE_X4
448 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
449 __ASM_EMIT("add $0x10, %[src]")
450 __ASM_EMIT("add $0x10, %[dst]")
451 __ASM_EMIT("sub $4, %[count]")
452 __ASM_EMIT("4:")
453 // Tail: 1x-3x block
454 __ASM_EMIT("add $4, %[count]")
455 __ASM_EMIT("jle 12f")
456 __ASM_EMIT("test $1, %[count]")
457 __ASM_EMIT("jz 6f")
458 __ASM_EMIT("movss 0x00(%[src]), %%xmm0")
459 __ASM_EMIT("add $4, %[src]")
460 __ASM_EMIT("6:")
461 __ASM_EMIT("test $2, %[count]")
462 __ASM_EMIT("jz 8f")
463 __ASM_EMIT("movhps 0x00(%[src]), %%xmm0")
464 __ASM_EMIT("8:")
465 LOGD_CORE_X4
466 __ASM_EMIT("test $1, %[count]")
467 __ASM_EMIT("jz 10f")
468 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
469 __ASM_EMIT("add $4, %[dst]")
470 __ASM_EMIT("10:")
471 __ASM_EMIT("test $2, %[count]")
472 __ASM_EMIT("jz 12f")
473 __ASM_EMIT("movhps %%xmm0, 0x00(%[dst])")
474
475 // End
476 __ASM_EMIT("12:")
477
478 : [dst] "+r" (dst), [src] "+r" (src), [count] "+r" (count)
479 : [L2C] "o" (LOG2_CONST),
480 [LOGC] "o" (LOGD_C)
481 : "cc", "memory",
482 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
483 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
484 );
485 }
486
487 void logd1(float *dst, size_t count)
488 {
489 IF_ARCH_X86(float *src);
490
491 ARCH_X86_ASM(
492 // x8 blocks
493 __ASM_EMIT("sub $8, %[count]")
494 __ASM_EMIT("jb 2f")
495 __ASM_EMIT("1:")
496 __ASM_EMIT("movups 0x00(%[dst]), %%xmm0")
497 __ASM_EMIT("movups 0x10(%[dst]), %%xmm4")
498 LOGD_CORE_X8
499 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
500 __ASM_EMIT("movups %%xmm4, 0x10(%[dst])")
501 __ASM_EMIT("add $0x20, %[dst]")
502 __ASM_EMIT("sub $8, %[count]")
503 __ASM_EMIT("jae 1b")
504 __ASM_EMIT("2:")
505 // x4 block
506 __ASM_EMIT("add $4, %[count]")
507 __ASM_EMIT("jl 4f")
508 __ASM_EMIT("movups 0x00(%[dst]), %%xmm0")
509 LOGD_CORE_X4
510 __ASM_EMIT("movups %%xmm0, 0x00(%[dst])")
511 __ASM_EMIT("add $0x10, %[dst]")
512 __ASM_EMIT("sub $4, %[count]")
513 __ASM_EMIT("4:")
514 // Tail: 1x-3x block
515 __ASM_EMIT("add $4, %[count]")
516 __ASM_EMIT("jle 12f")
517 __ASM_EMIT("mov %[dst], %[src]")
518 __ASM_EMIT("test $1, %[count]")
519 __ASM_EMIT("jz 6f")
520 __ASM_EMIT("movss 0x00(%[src]), %%xmm0")
521 __ASM_EMIT("add $4, %[src]")
522 __ASM_EMIT("6:")
523 __ASM_EMIT("test $2, %[count]")
524 __ASM_EMIT("jz 8f")
525 __ASM_EMIT("movhps 0x00(%[src]), %%xmm0")
526 __ASM_EMIT("8:")
527 LOGD_CORE_X4
528 __ASM_EMIT("test $1, %[count]")
529 __ASM_EMIT("jz 10f")
530 __ASM_EMIT("movss %%xmm0, 0x00(%[dst])")
531 __ASM_EMIT("add $4, %[dst]")
532 __ASM_EMIT("10:")
533 __ASM_EMIT("test $2, %[count]")
534 __ASM_EMIT("jz 12f")
535 __ASM_EMIT("movhps %%xmm0, 0x00(%[dst])")
536
537 // End
538 __ASM_EMIT("12:")
539
540 : [dst] "+r" (dst), [src] "=&r" (src), [count] "+r" (count)
541 : [L2C] "o" (LOG2_CONST),
542 [LOGC] "o" (LOGD_C)
543 : "cc", "memory",
544 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
545 "%xmm4", "%xmm5", "%xmm6", "%xmm7"
546 );
547 }
548
549 /*
550 float t_log2(float x)
551 {
552 union { float f; uint32_t i; } u;
553
554 x = fabs(x);
555 u.f = x;
556 int f = u.i >> 23; // f = mant(abs(x))
557 u.i = (u.i & 0x007fffff) | 0x3f800000;
558
559 float X = u.f; // x = frac(abs(x))
560 printf(" x = %.6f, f=%d (%d), u.f=%.6f, X=%.6f\n", x, f, f-127, u.f, X);
561
562 float y = (X-1)/(X+1);
563 float y2 = y*y;
564
565 float L = 1/9.0f + y2 * L;
566 L = 1/7.0f + y2 * L;
567 L = 1/5.0f + y2 * L;
568 L = 1/3.0f + y2 * L;
569 L = 1 + y2 * L;
570 L = 2 * y * L * M_LOG2E;
571
572 return L + (f - 127);
573 }
574 */
575 } /* namespace sse */
576 } /* namespace lsp */
577
578 #endif /* PRIVATE_DSP_ARCH_X86_SSE2_PMATH_LOG_H_ */