/* $NetBSD: memcmp.S,v 1.1 2014/09/03 19:34:25 matt Exp $ */
/*-
* Copyright (c) 2014 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Matt Thomas of 3am Software Foundry.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*
*
*
* int memcmp(const char *s1, const char *s2, size_t n);
*
* for (; n-- != 0; s1++, s2++) {
* if (*s1 < *s2)
* return -1;
* if (*s1 > *s2)
* return 1;
* }
* return 0;
*
* Return: ((s1 > s2) ? 1 : (s1 < s2) ? -1 : 0)
*
* ==========================================================================
*/
#include <machine/asm.h>
.text
.align 4
/* LINTSTUB: Func: void *memcmp(const void *, const void *, size_t) */
ENTRY(memcmp)
/*
* Check count passed in R5. If zero, return 0; otherwise continue.
*/
l.sfeqi r5, 0 /* nothing to compare? */
l.bf .Lret_0 /* yes, return equality */
l.nop
#ifdef _KERNEL
l.sfeqi r5, 6 /* less than two words? */
l.bnf .Lsixbyte_compare /* yes, just compare by bytes */
l.nop
#endif
l.sfgesi r5, 7 /* less than two words? */
l.bnf .Lbyte_compare /* yes, just compare by bytes */
l.nop
l.xor r6, r3, r4 /* check alignment compatibility */
l.andi r6, r6, 3 /* only care about the two bits */
l.sfeqi r6, 0 /* same alignment? */
l.bnf .Lmisaligned /* no, avoid alignment errors */
l.nop
/*
* At this point, we know we read the data via word accesses.
*/
l.andi r7, r3, 3 /* check alignment */
l.sfeqi r7, 0 /* word aligned? */
l.bf .Lword_compare /* yes, it is. */
l.sub r3, r3, r7 /* align string 1 */
l.sub r4, r4, r7 /* align string 2 */
l.add r5, r5, r7 /* pad length */
l.lwz r15, 0(r3) /* load word from s1 */
l.lwz r17, 0(r4) /* load word from s2 */
l.slli r7, r7, 3 /* bytes to bits */
l.sll r15, r15, r7 /* shift away leading bytes */
l.sll r17, r17, r7 /* shift away leading bytes */
l.j .Lword_compare /* now we can compare them */
l.nop
.Lword_loop:
l.lwz r15, 0(r3) /* load s1 word */
l.lwz r17, 0(r4) /* load s2 word */
.Lword_compare:
l.sfeq r15, r17 /* compare s1 and s2 words */
l.bnf .Lall_done /* different? we're done */
l.addi r3, r3, 4 /* advance s1 one word */
l.addi r4, r4, 4 /* advance s2 one word */
l.addi r5, r5, -4 /* decrement one word */
l.sfgtsi r5, 4 /* at least more than a word? */
l.bf .Lword_loop /* yes, loop around */
l.nop
l.sfeqi r5, 0 /* nothing left? */
l.bf .Lret_0 /* yes, return equality */
l.nop
/*
* Fall through to handle the last word
*/
l.sub r3, r0, r5 /* If count <= 4, handle */
l.andi r3, r3, 3 /* mask off low 2 bits */
l.slli r3, r3, 3 /* count *= 8 */
l.srl r15, r15, r3 /* discard extra s1 bytes */
l.srl r17, r17, r3 /* discard extra s2 bytes */
l.sfeq r17, r15 /* compare result */
l.bnf .Lall_done
.Lret_0:
l.addi r11, r0, 0
l.jr lr
l.nop
/*
* The two string don't have the same word alignment.
*/
.Lmisaligned:
l.sfeqi r6, 2 /* check for halfword alignment */
l.bnf .Lbyte_compare
l.nop
l.andi r7, r3, 1
l.sfeqi r7, 0
l.bf .Lhalfword_loop
l.nop
l.addi r5, r5, 1
l.addi r3, r3, -1
l.addi r4, r4, -1
l.lbz r15, 1(r3)
l.lbz r17, 1(r4)
l.j .Lhalfword_compare
l.nop
.Lhalfword_loop:
l.lhz r15, 0(r3)
l.lhz r17, 0(r4)
.Lhalfword_compare:
l.sfeq r15, r17
l.bnf .Lall_done
l.nop
l.addi r3, r3, 2
l.addi r4, r4, 2
l.addi r5, r5, -2
l.sfgesi r5, 2
l.bf .Lhalfword_loop
l.nop
.Lbyte_compare:
l.addi r5, r5, -1
l.sfgesi r5, 0
l.bnf .Lret_0
l.nop
l.lbz r15, 0(r3)
l.lbz r17, 0(r4)
l.addi r3, r3, 1
l.addi r4, r4, 1
l.sfeq r15, r17
l.bf .Lbyte_compare
l.nop
.Lall_done:
l.sub r11, r15, r17 /* subtract s2 from s1 */
l.srai r11, r11, 30 /* replicate sign bit thru bit 1 */
l.ori r11, r11, 1 /* make sure bit 0 is set */
l.jr lr
l.nop
#ifdef _KERNEL
.Lsixbyte_compare:
l.or r7, r3, r4
l.andi r7, r7, 1
l.sfeqi r7, 0
l.bnf .Lbyte_compare
l.nop
l.lhz r15, 0(r3)
l.lhz r17, 0(r4)
l.sfeq r15, r17
l.bnf .Lall_done
l.nop
l.lhz r15, 2(r3)
l.lhz r17, 2(r4)
l.sfeq r15, r17
l.bnf .Lall_done
l.nop
l.lhz r15, 4(r3)
l.lhz r17, 4(r4)
l.sfeq r15, r17
l.bnf .Lall_done
l.nop
l.addi r11, r0, 0
l.jr lr
l.nop
#endif
END(memcmp)