Loading...
--- /dev/null
+++ Libc/Libc-825.26/arm/string/strnlen.s
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2011 Apple, Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+#include <arm/arch.h>
+.syntax unified
+.code 32
+.globl _strnlen
+
+#define addr r0
+#define maxl r1
+#define temp r2
+#define mask r3
+#define save ip
+#define word lr
+#define byte lr
+#define indx r0
+
+.macro IfHS_and_WordDoesntContainNUL_SetZ
+#if defined _ARM_ARCH_6
+// In each word of the string, we check for NUL bytes via a saturating
+// unsigned subtraction of each byte from 0x1. The result of this is
+// non-zero if and only if the corresponding byte in the string is NUL.
+// Simply using a TST instruction checks all four bytes for NULs in one
+// go.
+ uqsub8 temp, mask, word
+ tsths temp, temp
+#else
+// If we're on armv5, we do not have the uqsub8 instruction, so we need
+// to use a different test for NUL. Instead, we compute:
+//
+// byte - 0x1 & ~byte
+//
+// and test the high-order bit. If it is set, then byte is NUL. Just
+// as with the other test, this can be applied simultaneously to all
+// bytes in a word.
+ sub temp, word, mask
+ bic temp, temp, word
+ tsths temp, mask, lsl #7
+#endif
+.endm
+
+.text
+.align 3
+.long 0x0 // padding
+.long 0x01010101 // mask for use in finding NULs
+_strnlen:
+// Establish stack frame, load mask that we will use to find NUL bytes,
+// and set aside a copy of the pointer to the string. Subtract 4 from
+// the maxlen, and jump into a byte-by-byte search if this requires a
+// borrow, as we cannot use a word-by-word search in that case.
+ push {r7,lr}
+ mov r7, sp
+ ldr mask, (_strnlen-4)
+ add save, addr, #4
+ subs maxl, maxl, #4
+ blo L_bytewiseSearch
+
+// Load the aligned word that contains the start of the string, then OR
+// 0x01 into any bytes that preceed the start to prevent false positives
+// when we check for NUL bytes. Additionally, add the number of unused
+// bytes to maxlen.
+ and temp, addr, #3
+ bic addr, addr, #3
+ add maxl, maxl, temp
+ lsl temp, temp, #3
+ ldr word, [addr], #4
+ rsb temp, temp, #32
+ orr word, word, mask, lsr temp
+
+ subs maxl, maxl, #4
+ IfHS_and_WordDoesntContainNUL_SetZ
+ bne 1f
+
+.align 4
+0: ldr word, [addr], #4
+ subs maxl, maxl, #4
+ IfHS_and_WordDoesntContainNUL_SetZ
+ beq 0b
+
+.align 4
+// Either the last word that we loaded contained a NUL, or we will
+// exceed maxlen before we finish the next word in the string. Determine
+// which case we are in by repeating the check for NUL, and branch if
+// there was not a NUL byte. Padding ensures that we don't have two
+// branches in a single 16-byte fetch group, as this interferes with
+// branch prediction on Swift.
+1: tst temp, temp
+ beq L_bytewiseSearch
+
+// The last word that we loaded contained a NUL. Subtracting the saved
+// pointer from the current pointer gives us the number of bytes from
+// the start of the string to the word containing the NUL.
+ sub indx, addr, save
+#if defined _ARM_ARCH_6
+// To that we add the index of the first NUL byte in the word, computed
+// using REV and CLZ followed by a shift.
+ rev temp, temp
+ clz temp, temp
+ add indx, indx, temp, lsr #3
+#else
+// armv5 does not have the REV instruction, so instead we find the
+// index of the NUL byte in word with a linear search.
+ tst word, #0x000000ff
+ addne indx, #1
+ tstne word, #0x0000ff00
+ addne indx, #1
+ tstne word, #0x00ff0000
+ addne indx, #1
+#endif
+ pop {r7,pc}
+
+.align 4
+L_bytewiseSearch:
+// Restore maxlen (the last thing that happened before we branched here
+// was that we subtracted 4 from maxlen), and adjust the saved string
+// pointer. Then we do a simple byte-by-byte search until we either
+// reach the end of the string or maxlen reaches zero, at which point
+// the length to return is simply the difference between the current
+// and saved pointers.
+ adds maxl, maxl, #4
+ sub save, save, #4
+ beq 1f
+0: ldrb byte, [addr]
+ cmp byte, #0
+ addhi addr, #1
+ subshi maxl, #1
+ bhi 0b
+1: sub indx, addr, save
+ pop {r7,pc}