Commit aae5560712fb67cea2b1405c4e2b03e9be236678 | zig

lib/libc/musl/src/string/aarch64/memset.S deleted-115

...	@@ -1,115 +0,0 @@
1	/*
2	* memset - fill memory with a constant byte
3	*
4	* Copyright (c) 2012-2020, Arm Limited.
5	* SPDX-License-Identifier: MIT
6	*/
7
8	/* Assumptions:
9	*
10	* ARMv8-a, AArch64, Advanced SIMD, unaligned accesses.
11	*
12	*/
13
14	#define dstin x0
15	#define val x1
16	#define valw w1
17	#define count x2
18	#define dst x3
19	#define dstend x4
20	#define zva_val x5
21
22	.global memset
23	.type memset,%function
24	memset:
25
26	dup v0.16B, valw
27	add dstend, dstin, count
28
29	cmp count, 96
30	b.hi .Lset_long
31	cmp count, 16
32	b.hs .Lset_medium
33	mov val, v0.D[0]
34
35	/* Set 0..15 bytes. */
36	tbz count, 3, 1f
37	str val, [dstin]
38	str val, [dstend, -8]
39	ret
40	nop
41	1: tbz count, 2, 2f
42	str valw, [dstin]
43	str valw, [dstend, -4]
44	ret
45	2: cbz count, 3f
46	strb valw, [dstin]
47	tbz count, 1, 3f
48	strh valw, [dstend, -2]
49	3: ret
50
51	/* Set 17..96 bytes. */
52	.Lset_medium:
53	str q0, [dstin]
54	tbnz count, 6, .Lset96
55	str q0, [dstend, -16]
56	tbz count, 5, 1f
57	str q0, [dstin, 16]
58	str q0, [dstend, -32]
59	1: ret
60
61	.p2align 4
62	/* Set 64..96 bytes. Write 64 bytes from the start and
63	32 bytes from the end. */
64	.Lset96:
65	str q0, [dstin, 16]
66	stp q0, q0, [dstin, 32]
67	stp q0, q0, [dstend, -32]
68	ret
69
70	.p2align 4
71	.Lset_long:
72	and valw, valw, 255
73	bic dst, dstin, 15
74	str q0, [dstin]
75	cmp count, 160
76	ccmp valw, 0, 0, hs
77	b.ne .Lno_zva
78
79	#ifndef SKIP_ZVA_CHECK
80	mrs zva_val, dczid_el0
81	and zva_val, zva_val, 31
82	cmp zva_val, 4 /* ZVA size is 64 bytes. */
83	b.ne .Lno_zva
84	#endif
85	str q0, [dst, 16]
86	stp q0, q0, [dst, 32]
87	bic dst, dst, 63
88	sub count, dstend, dst /* Count is now 64 too large. */
89	sub count, count, 128 /* Adjust count and bias for loop. */
90
91	.p2align 4
92	.Lzva_loop:
93	add dst, dst, 64
94	dc zva, dst
95	subs count, count, 64
96	b.hi .Lzva_loop
97	stp q0, q0, [dstend, -64]
98	stp q0, q0, [dstend, -32]
99	ret
100
101	.Lno_zva:
102	sub count, dstend, dst /* Count is 16 too large. */
103	sub dst, dst, 16 /* Dst is biased by -32. */
104	sub count, count, 64 + 16 /* Adjust count and bias for loop. */
105	.Lno_zva_loop:
106	stp q0, q0, [dst, 32]
107	stp q0, q0, [dst, 64]!
108	subs count, count, 64
109	b.hi .Lno_zva_loop
110	stp q0, q0, [dstend, -64]
111	stp q0, q0, [dstend, -32]
112	ret
113
114	.size memset,.-memset
115

lib/libc/musl/src/string/arm/__aeabi_memset.s deleted-31

...	@@ -1,31 +0,0 @@
1	.syntax unified
2
3	.global __aeabi_memclr8
4	.global __aeabi_memclr4
5	.global __aeabi_memclr
6	.global __aeabi_memset8
7	.global __aeabi_memset4
8	.global __aeabi_memset
9
10	.type __aeabi_memclr8,%function
11	.type __aeabi_memclr4,%function
12	.type __aeabi_memclr,%function
13	.type __aeabi_memset8,%function
14	.type __aeabi_memset4,%function
15	.type __aeabi_memset,%function
16
17	__aeabi_memclr8:
18	__aeabi_memclr4:
19	__aeabi_memclr:
20	movs r2, #0
21	__aeabi_memset8:
22	__aeabi_memset4:
23	__aeabi_memset:
24	cmp r1, #0
25	beq 2f
26	adds r1, r0, r1
27	1: strb r2, [r0]
28	adds r0, r0, #1
29	cmp r1, r0
30	bne 1b
31	2: bx lr

lib/libc/musl/src/string/i386/memset.s deleted-76

...	@@ -1,76 +0,0 @@
1	.global memset
2	.type memset,@function
3	memset:
4	mov 12(%esp),%ecx
5	cmp $62,%ecx
6	ja 2f
7
8	mov 8(%esp),%dl
9	mov 4(%esp),%eax
10	test %ecx,%ecx
11	jz 1f
12
13	mov %dl,%dh
14
15	mov %dl,(%eax)
16	mov %dl,-1(%eax,%ecx)
17	cmp $2,%ecx
18	jbe 1f
19
20	mov %dx,1(%eax)
21	mov %dx,(-1-2)(%eax,%ecx)
22	cmp $6,%ecx
23	jbe 1f
24
25	shl $16,%edx
26	mov 8(%esp),%dl
27	mov 8(%esp),%dh
28
29	mov %edx,(1+2)(%eax)
30	mov %edx,(-1-2-4)(%eax,%ecx)
31	cmp $14,%ecx
32	jbe 1f
33
34	mov %edx,(1+2+4)(%eax)
35	mov %edx,(1+2+4+4)(%eax)
36	mov %edx,(-1-2-4-8)(%eax,%ecx)
37	mov %edx,(-1-2-4-4)(%eax,%ecx)
38	cmp $30,%ecx
39	jbe 1f
40
41	mov %edx,(1+2+4+8)(%eax)
42	mov %edx,(1+2+4+8+4)(%eax)
43	mov %edx,(1+2+4+8+8)(%eax)
44	mov %edx,(1+2+4+8+12)(%eax)
45	mov %edx,(-1-2-4-8-16)(%eax,%ecx)
46	mov %edx,(-1-2-4-8-12)(%eax,%ecx)
47	mov %edx,(-1-2-4-8-8)(%eax,%ecx)
48	mov %edx,(-1-2-4-8-4)(%eax,%ecx)
49
50	1: ret
51
52	2: movzbl 8(%esp),%eax
53	mov %edi,12(%esp)
54	imul $0x1010101,%eax
55	mov 4(%esp),%edi
56	test $15,%edi
57	mov %eax,-4(%edi,%ecx)
58	jnz 2f
59
60	1: shr $2, %ecx
61	rep
62	stosl
63	mov 4(%esp),%eax
64	mov 12(%esp),%edi
65	ret
66
67	2: xor %edx,%edx
68	sub %edi,%edx
69	and $15,%edx
70	mov %eax,(%edi)
71	mov %eax,4(%edi)
72	mov %eax,8(%edi)
73	mov %eax,12(%edi)
74	sub %edx,%ecx
75	add %edx,%edi
76	jmp 1b

lib/libc/musl/src/string/memcmp.c deleted-8

...	@@ -1,8 +0,0 @@
1	#include <string.h>
2
3	int memcmp(const void vl, const void vr, size_t n)
4	{
5	const unsigned char l=vl, r=vr;
6	for (; n && l == r; n--, l++, r++);
7	return n ? l-r : 0;
8	}

lib/libc/musl/src/string/memset.c deleted-90

...	@@ -1,90 +0,0 @@
1	#include <string.h>
2	#include <stdint.h>
3
4	void memset(void dest, int c, size_t n)
5	{
6	unsigned char *s = dest;
7	size_t k;
8
9	/* Fill head and tail with minimal branching. Each
10	* conditional ensures that all the subsequently used
11	* offsets are well-defined and in the dest region. */
12
13	if (!n) return dest;
14	s[0] = c;
15	s[n-1] = c;
16	if (n <= 2) return dest;
17	s[1] = c;
18	s[2] = c;
19	s[n-2] = c;
20	s[n-3] = c;
21	if (n <= 6) return dest;
22	s[3] = c;
23	s[n-4] = c;
24	if (n <= 8) return dest;
25
26	/* Advance pointer to align it at a 4-byte boundary,
27	* and truncate n to a multiple of 4. The previous code
28	* already took care of any head/tail that get cut off
29	* by the alignment. */
30
31	k = -(uintptr_t)s & 3;
32	s += k;
33	n -= k;
34	n &= -4;
35
36	#ifdef __GNUC__
37	typedef uint32_t __attribute__((__may_alias__)) u32;
38	typedef uint64_t __attribute__((__may_alias__)) u64;
39
40	u32 c32 = ((u32)-1)/255 * (unsigned char)c;
41
42	/* In preparation to copy 32 bytes at a time, aligned on
43	* an 8-byte bounary, fill head/tail up to 28 bytes each.
44	* As in the initial byte-based head/tail fill, each
45	* conditional below ensures that the subsequent offsets
46	* are valid (e.g. !(n<=24) implies n>=28). */
47
48	(u32 )(s+0) = c32;
49	(u32 )(s+n-4) = c32;
50	if (n <= 8) return dest;
51	(u32 )(s+4) = c32;
52	(u32 )(s+8) = c32;
53	(u32 )(s+n-12) = c32;
54	(u32 )(s+n-8) = c32;
55	if (n <= 24) return dest;
56	(u32 )(s+12) = c32;
57	(u32 )(s+16) = c32;
58	(u32 )(s+20) = c32;
59	(u32 )(s+24) = c32;
60	(u32 )(s+n-28) = c32;
61	(u32 )(s+n-24) = c32;
62	(u32 )(s+n-20) = c32;
63	(u32 )(s+n-16) = c32;
64
65	/* Align to a multiple of 8 so we can fill 64 bits at a time,
66	* and avoid writing the same bytes twice as much as is
67	* practical without introducing additional branching. */
68
69	k = 24 + ((uintptr_t)s & 4);
70	s += k;
71	n -= k;
72
73	/* If this loop is reached, 28 tail bytes have already been
74	* filled, so any remainder when n drops below 32 can be
75	* safely ignored. */
76
77	u64 c64 = c32 \| ((u64)c32 << 32);
78	for (; n >= 32; n-=32, s+=32) {
79	(u64 )(s+0) = c64;
80	(u64 )(s+8) = c64;
81	(u64 )(s+16) = c64;
82	(u64 )(s+24) = c64;
83	}
84	#else
85	/* Pure C fallback with no aliasing violations. */
86	for (; n; n--, s++) *s = c;
87	#endif
88
89	return dest;
90	}

lib/libc/musl/src/string/x86_64/memset.s deleted-72

...	@@ -1,72 +0,0 @@
1	.global memset
2	.type memset,@function
3	memset:
4	movzbq %sil,%rax
5	mov $0x101010101010101,%r8
6	imul %r8,%rax
7
8	cmp $126,%rdx
9	ja 2f
10
11	test %edx,%edx
12	jz 1f
13
14	mov %sil,(%rdi)
15	mov %sil,-1(%rdi,%rdx)
16	cmp $2,%edx
17	jbe 1f
18
19	mov %ax,1(%rdi)
20	mov %ax,(-1-2)(%rdi,%rdx)
21	cmp $6,%edx
22	jbe 1f
23
24	mov %eax,(1+2)(%rdi)
25	mov %eax,(-1-2-4)(%rdi,%rdx)
26	cmp $14,%edx
27	jbe 1f
28
29	mov %rax,(1+2+4)(%rdi)
30	mov %rax,(-1-2-4-8)(%rdi,%rdx)
31	cmp $30,%edx
32	jbe 1f
33
34	mov %rax,(1+2+4+8)(%rdi)
35	mov %rax,(1+2+4+8+8)(%rdi)
36	mov %rax,(-1-2-4-8-16)(%rdi,%rdx)
37	mov %rax,(-1-2-4-8-8)(%rdi,%rdx)
38	cmp $62,%edx
39	jbe 1f
40
41	mov %rax,(1+2+4+8+16)(%rdi)
42	mov %rax,(1+2+4+8+16+8)(%rdi)
43	mov %rax,(1+2+4+8+16+16)(%rdi)
44	mov %rax,(1+2+4+8+16+24)(%rdi)
45	mov %rax,(-1-2-4-8-16-32)(%rdi,%rdx)
46	mov %rax,(-1-2-4-8-16-24)(%rdi,%rdx)
47	mov %rax,(-1-2-4-8-16-16)(%rdi,%rdx)
48	mov %rax,(-1-2-4-8-16-8)(%rdi,%rdx)
49
50	1: mov %rdi,%rax
51	ret
52
53	2: test $15,%edi
54	mov %rdi,%r8
55	mov %rax,-8(%rdi,%rdx)
56	mov %rdx,%rcx
57	jnz 2f
58
59	1: shr $3,%rcx
60	rep
61	stosq
62	mov %r8,%rax
63	ret
64
65	2: xor %edx,%edx
66	sub %edi,%edx
67	and $15,%edx
68	mov %rax,(%rdi)
69	mov %rax,8(%rdi)
70	sub %rdx,%rcx
71	add %rdx,%rdi
72	jmp 1b

lib/libc/wasi/libc-top-half/musl/src/string/memcmp.c deleted-43

...	@@ -1,43 +0,0 @@
1	#include <string.h>
2
3	#ifdef __wasm_simd128__
4	#include <wasm_simd128.h>
5	#endif
6
7	int memcmp(const void vl, const void vr, size_t n)
8	{
9	#if defined(__wasm_simd128__) && defined(__wasilibc_simd_string)
10	if (n >= sizeof(v128_t)) {
11	// memcmp is allowed to read up to n bytes from each object.
12	// Find the first different character in the objects.
13	// Unaligned loads handle the case where the objects
14	// have mismatching alignments.
15	const v128_t v1 = (v128_t )vl;
16	const v128_t v2 = (v128_t )vr;
17	while (n) {
18	const v128_t cmp = wasm_i8x16_eq(wasm_v128_load(v1), wasm_v128_load(v2));
19	// Bitmask is slow on AArch64, all_true is much faster.
20	if (!wasm_i8x16_all_true(cmp)) {
21	// Find the offset of the first zero bit (little-endian).
22	size_t ctz = __builtin_ctz(~wasm_i8x16_bitmask(cmp));
23	const unsigned char u1 = (unsigned char )v1 + ctz;
24	const unsigned char u2 = (unsigned char )v2 + ctz;
25	// This may help the compiler if the function is inlined.
26	__builtin_assume(u1 - u2 != 0);
27	return u1 - u2;
28	}
29	// This makes n a multiple of sizeof(v128_t)
30	// for every iteration except the first.
31	size_t align = (n - 1) % sizeof(v128_t) + 1;
32	v1 = (v128_t )((char )v1 + align);
33	v2 = (v128_t )((char )v2 + align);
34	n -= align;
35	}
36	return 0;
37	}
38	#endif
39
40	const unsigned char l=vl, r=vr;
41	for (; n && l == r; n--, l++, r++);
42	return n ? l-r : 0;
43	}

lib/libc/wasi/libc-top-half/musl/src/string/memset.c deleted-94

...	@@ -1,94 +0,0 @@
1	#include <string.h>
2	#include <stdint.h>
3
4	void memset(void dest, int c, size_t n)
5	{
6	#if defined(__wasm_bulk_memory__)
7	if (n > BULK_MEMORY_THRESHOLD)
8	return __builtin_memset(dest, c, n);
9	#endif
10	unsigned char *s = dest;
11	size_t k;
12
13	/* Fill head and tail with minimal branching. Each
14	* conditional ensures that all the subsequently used
15	* offsets are well-defined and in the dest region. */
16
17	if (!n) return dest;
18	s[0] = c;
19	s[n-1] = c;
20	if (n <= 2) return dest;
21	s[1] = c;
22	s[2] = c;
23	s[n-2] = c;
24	s[n-3] = c;
25	if (n <= 6) return dest;
26	s[3] = c;
27	s[n-4] = c;
28	if (n <= 8) return dest;
29
30	/* Advance pointer to align it at a 4-byte boundary,
31	* and truncate n to a multiple of 4. The previous code
32	* already took care of any head/tail that get cut off
33	* by the alignment. */
34
35	k = -(uintptr_t)s & 3;
36	s += k;
37	n -= k;
38	n &= -4;
39
40	#ifdef __GNUC__
41	typedef uint32_t __attribute__((__may_alias__)) u32;
42	typedef uint64_t __attribute__((__may_alias__)) u64;
43
44	u32 c32 = ((u32)-1)/255 * (unsigned char)c;
45
46	/* In preparation to copy 32 bytes at a time, aligned on
47	* an 8-byte bounary, fill head/tail up to 28 bytes each.
48	* As in the initial byte-based head/tail fill, each
49	* conditional below ensures that the subsequent offsets
50	* are valid (e.g. !(n<=24) implies n>=28). */
51
52	(u32 )(s+0) = c32;
53	(u32 )(s+n-4) = c32;
54	if (n <= 8) return dest;
55	(u32 )(s+4) = c32;
56	(u32 )(s+8) = c32;
57	(u32 )(s+n-12) = c32;
58	(u32 )(s+n-8) = c32;
59	if (n <= 24) return dest;
60	(u32 )(s+12) = c32;
61	(u32 )(s+16) = c32;
62	(u32 )(s+20) = c32;
63	(u32 )(s+24) = c32;
64	(u32 )(s+n-28) = c32;
65	(u32 )(s+n-24) = c32;
66	(u32 )(s+n-20) = c32;
67	(u32 )(s+n-16) = c32;
68
69	/* Align to a multiple of 8 so we can fill 64 bits at a time,
70	* and avoid writing the same bytes twice as much as is
71	* practical without introducing additional branching. */
72
73	k = 24 + ((uintptr_t)s & 4);
74	s += k;
75	n -= k;
76
77	/* If this loop is reached, 28 tail bytes have already been
78	* filled, so any remainder when n drops below 32 can be
79	* safely ignored. */
80
81	u64 c64 = c32 \| ((u64)c32 << 32);
82	for (; n >= 32; n-=32, s+=32) {
83	(u64 )(s+0) = c64;
84	(u64 )(s+8) = c64;
85	(u64 )(s+16) = c64;
86	(u64 )(s+24) = c64;
87	}
88	#else
89	/* Pure C fallback with no aliasing violations. */
90	for (; n; n--, s++) *s = c;
91	#endif
92
93	return dest;
94	}

src/libs/musl.zig-6

 @@ -1786,20 +1786,15 @@ const src_files = [_][]const u8{
     "musl/src/stdlib/strtol.c",
     "musl/src/stdlib/wcstod.c",
     "musl/src/stdlib/wcstol.c",
-    "musl/src/string/aarch64/memset.S",
-    "musl/src/string/arm/__aeabi_memset.s",
     "musl/src/string/bcmp.c",
     "musl/src/string/bcopy.c",
     "musl/src/string/explicit_bzero.c",
-    "musl/src/string/i386/memset.s",
     "musl/src/string/index.c",
     "musl/src/string/memccpy.c",
     "musl/src/string/memchr.c",
-    "musl/src/string/memcmp.c",
     "musl/src/string/memmem.c",
     "musl/src/string/mempcpy.c",
     "musl/src/string/memrchr.c",
-    "musl/src/string/memset.c",
     "musl/src/string/rindex.c",
     "musl/src/string/stpcpy.c",
     "musl/src/string/stpncpy.c",
 @@ -1855,7 +1850,6 @@ const src_files = [_][]const u8{
     "musl/src/string/wmemcpy.c",
     "musl/src/string/wmemmove.c",
     "musl/src/string/wmemset.c",
-    "musl/src/string/x86_64/memset.s",
     "musl/src/temp/mkdtemp.c",
     "musl/src/temp/mkostemp.c",
     "musl/src/temp/mkostemps.c",

src/libs/wasi_libc.zig-2

 @@ -1221,9 +1221,7 @@ const libc_top_half_src_files = [_][]const u8{
     "wasi/libc-top-half/musl/src/stdlib/wcstod.c",
     "wasi/libc-top-half/musl/src/stdlib/wcstol.c",
     "wasi/libc-top-half/musl/src/string/memchr.c",
-    "wasi/libc-top-half/musl/src/string/memcmp.c",
     "wasi/libc-top-half/musl/src/string/memrchr.c",
-    "wasi/libc-top-half/musl/src/string/memset.c",
     "wasi/libc-top-half/musl/src/string/strchrnul.c",
     "wasi/libc-top-half/musl/src/thread/pthread_attr_get.c",
     "wasi/libc-top-half/musl/src/thread/pthread_attr_setguardsize.c",

author	Yefeng Li <yefeng@emma-app.com> 2025-08-25 18:07:07+01:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2025-08-27 03:35:18+02:00
log	aae5560712fb67cea2b1405c4e2b03e9be236678
tree	d0ba70e9a7281c8241639f10fbc721a2e6554a2c
parent	42eb1329b1b9f41fe64e96c9c15afb486d0a1666

...	@@ -1,8 +0,0 @@
1	#include <string.h>
2
3	int memcmp(const void vl, const void vr, size_t n)
4	{
5	const unsigned char l=vl, r=vr;
6	for (; n && l == r; n--, l++, r++);
7	return n ? l-r : 0;
8	}

Remove memcmp and memset from bundled musl and wasi