glibc/sysdeps/i386/i686/memcmp.S

/* Compare two memory blocks for differences in the first COUNT bytes.
   Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

#include <sysdep.h>
#include "asm-syntax.h"
#include "bp-sym.h"
#include "bp-asm.h"

#define PARMS		LINKAGE+4	/* Preserve EBX.  */
#define BLK1		PARMS
#define BLK2		BLK1+PTR_SIZE
#define LEN		BLK2+PTR_SIZE
#define ENTRANCE	pushl %ebx; cfi_adjust_cfa_offset (4); \
			cfi_rel_offset (ebx, 0); ENTER
#define RETURN		popl %ebx; cfi_adjust_cfa_offset (-4); \
			cfi_restore (ebx); LEAVE; ret

/* Load an entry in a jump table into EBX.  TABLE is a jump table
   with relative offsets.  INDEX is a register contains the index
   into the jump table.  */
#define LOAD_JUMP_TABLE_ENTRY(TABLE, INDEX) \
  /* We first load PC into EBX.  */					      \
  call	__i686.get_pc_thunk.bx;						      \
  /* Get the address of the jump table.  */				      \
  addl	$(TABLE - .), %ebx;						      \
  /* Get the entry and convert the relative offset to the		      \
     absolute address.  */						      \
  addl	(%ebx,INDEX,4), %ebx

	.section	.gnu.linkonce.t.__i686.get_pc_thunk.bx,"ax",@progbits
	.globl	__i686.get_pc_thunk.bx
	.hidden	__i686.get_pc_thunk.bx
	ALIGN (4)
	.type	__i686.get_pc_thunk.bx,@function
__i686.get_pc_thunk.bx:
	movl	(%esp), %ebx
	ret

        .text
	ALIGN (4)
ENTRY (BP_SYM (memcmp))
	ENTRANCE

	movl	BLK1(%esp), %eax
	movl	BLK2(%esp), %edx
	movl	LEN(%esp), %ecx

	cmpl 	$1, %ecx
	jne	L(not_1)
	movzbl	(%eax), %ecx		/* LEN == 1  */
	cmpb	(%edx), %cl
	jne	L(neq)
L(bye):
	xorl	%eax, %eax
	RETURN

	cfi_adjust_cfa_offset (4)
	cfi_rel_offset (ebx, 0)
L(neq):
	sbbl	%eax, %eax
	sbbl	$-1, %eax
	RETURN

	cfi_adjust_cfa_offset (4)
	cfi_rel_offset (ebx, 0)
L(not_1):
	jl	L(bye)			/* LEN == 0  */

	pushl	%esi
	cfi_adjust_cfa_offset (4)
	movl	%eax, %esi
	cfi_rel_offset (esi, 0)
	cmpl	$32, %ecx;
	jge	L(32bytesormore)	/* LEN => 32  */

	LOAD_JUMP_TABLE_ENTRY (L(table_32bytes), %ecx)
	addl	%ecx, %edx
	addl	%ecx, %esi
	jmp	*%ebx

	ALIGN (4)
L(28bytes):
	movl	-28(%esi), %eax
	movl	-28(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(24bytes):
	movl	-24(%esi), %eax
	movl	-24(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(20bytes):
	movl	-20(%esi), %eax
	movl	-20(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(16bytes):
	movl	-16(%esi), %eax
	movl	-16(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(12bytes):
	movl	-12(%esi), %eax
	movl	-12(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(8bytes):
	movl	-8(%esi), %eax
	movl	-8(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(4bytes):
	movl	-4(%esi), %eax
	movl	-4(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(0bytes):
	popl	%esi
	cfi_adjust_cfa_offset (-4)
	cfi_restore (esi)
	xorl	%eax, %eax
	RETURN

	cfi_adjust_cfa_offset (8)
	cfi_rel_offset (esi, 0)
	cfi_rel_offset (ebx, 4)
L(29bytes):
	movl	-29(%esi), %eax
	movl	-29(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(25bytes):
	movl	-25(%esi), %eax
	movl	-25(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(21bytes):
	movl	-21(%esi), %eax
	movl	-21(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(17bytes):
	movl	-17(%esi), %eax
	movl	-17(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(13bytes):
	movl	-13(%esi), %eax
	movl	-13(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(9bytes):
	movl	-9(%esi), %eax
	movl	-9(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(5bytes):
	movl	-5(%esi), %eax
	movl	-5(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(1bytes):
	movzbl	-1(%esi), %eax
	cmpb	-1(%edx), %al
	jne	L(set)
	popl	%esi
	cfi_adjust_cfa_offset (-4)
	cfi_restore (esi)
	xorl	%eax, %eax
	RETURN

	cfi_adjust_cfa_offset (8)
	cfi_rel_offset (esi, 0)
	cfi_rel_offset (ebx, 4)
L(30bytes):
	movl	-30(%esi), %eax
	movl	-30(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(26bytes):
	movl	-26(%esi), %eax
	movl	-26(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(22bytes):
	movl	-22(%esi), %eax
	movl	-22(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(18bytes):
	movl	-18(%esi), %eax
	movl	-18(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(14bytes):
	movl	-14(%esi), %eax
	movl	-14(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(10bytes):
	movl	-10(%esi), %eax
	movl	-10(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(6bytes):
	movl	-6(%esi), %eax
	movl	-6(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(2bytes):
	movzwl	-2(%esi), %eax
	movzwl	-2(%edx), %ecx
	cmpb	%cl, %al
	jne	L(set)
	cmpl	%ecx, %eax
	jne	L(set)
	popl	%esi
	cfi_adjust_cfa_offset (-4)
	cfi_restore (esi)
	xorl	%eax, %eax
	RETURN

	cfi_adjust_cfa_offset (8)
	cfi_rel_offset (esi, 0)
	cfi_rel_offset (ebx, 4)
L(31bytes):
	movl	-31(%esi), %eax
	movl	-31(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(27bytes):
	movl	-27(%esi), %eax
	movl	-27(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(23bytes):
	movl	-23(%esi), %eax
	movl	-23(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(19bytes):
	movl	-19(%esi), %eax
	movl	-19(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(15bytes):
	movl	-15(%esi), %eax
	movl	-15(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(11bytes):
	movl	-11(%esi), %eax
	movl	-11(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(7bytes):
	movl	-7(%esi), %eax
	movl	-7(%edx), %ecx
	cmpl	%ecx, %eax
	jne	L(find_diff)
L(3bytes):
	movzwl	-3(%esi), %eax
	movzwl	-3(%edx), %ecx
	cmpb	%cl, %al
	jne	L(set)
	cmpl	%ecx, %eax
	jne	L(set)
	movzbl	-1(%esi), %eax
	cmpb	-1(%edx), %al
	jne	L(set)
	popl	%esi
	cfi_adjust_cfa_offset (-4)
	cfi_restore (esi)
	xorl	%eax, %eax
	RETURN

	cfi_adjust_cfa_offset (8)
	cfi_rel_offset (esi, 0)
	cfi_rel_offset (ebx, 4)
	ALIGN (4)
/* ECX >= 32.  */
L(32bytesormore):
	subl	$32, %ecx

	movl	(%esi), %eax
	cmpl	(%edx), %eax
	jne	L(load_ecx)

	movl	4(%esi), %eax
	cmpl	4(%edx), %eax
	jne	L(load_ecx_4)

	movl	8(%esi), %eax
	cmpl	8(%edx), %eax
	jne	L(load_ecx_8)

	movl	12(%esi), %eax
	cmpl	12(%edx), %eax
	jne	L(load_ecx_12)

	movl	16(%esi), %eax
	cmpl	16(%edx), %eax
	jne	L(load_ecx_16)

	movl	20(%esi), %eax
	cmpl	20(%edx), %eax
	jne	L(load_ecx_20)

	movl	24(%esi), %eax
	cmpl	24(%edx), %eax
	jne	L(load_ecx_24)

	movl	28(%esi), %eax
	cmpl	28(%edx), %eax
	jne	L(load_ecx_28)

	addl	$32, %esi
	addl	$32, %edx
	cmpl	$32, %ecx
	jge	L(32bytesormore)

	LOAD_JUMP_TABLE_ENTRY (L(table_32bytes), %ecx)
	addl	%ecx, %edx
	addl	%ecx, %esi
	jmp	*%ebx

L(load_ecx_28):
	addl	$0x4, %edx
L(load_ecx_24):
	addl	$0x4, %edx
L(load_ecx_20):
	addl	$0x4, %edx
L(load_ecx_16):
	addl	$0x4, %edx
L(load_ecx_12):
	addl	$0x4, %edx
L(load_ecx_8):
	addl	$0x4, %edx
L(load_ecx_4):
	addl	$0x4, %edx
L(load_ecx):
	movl	(%edx), %ecx

L(find_diff):
	cmpb	%cl, %al
	jne	L(set)
	cmpb	%ch, %ah
	jne	L(set)
	shrl	$16,%eax
	shrl	$16,%ecx
	cmpb	%cl, %al
	jne	L(set)
	/* We get there only if we already know there is a
	   difference.  */
	cmpl	%ecx, %eax
L(set):
	sbbl	%eax, %eax
	sbbl	$-1, %eax
	popl	%esi
	cfi_adjust_cfa_offset (-4)
	cfi_restore (esi)
	RETURN
END (BP_SYM (memcmp))

	.section	.rodata
	ALIGN (2)
L(table_32bytes) :
	.long	L(0bytes) - L(table_32bytes)
	.long	L(1bytes) - L(table_32bytes)
	.long	L(2bytes) - L(table_32bytes)
	.long	L(3bytes) - L(table_32bytes)
	.long	L(4bytes) - L(table_32bytes)
	.long	L(5bytes) - L(table_32bytes)
	.long	L(6bytes) - L(table_32bytes)
	.long	L(7bytes) - L(table_32bytes)
	.long	L(8bytes) - L(table_32bytes)
	.long	L(9bytes) - L(table_32bytes)
	.long	L(10bytes) - L(table_32bytes)
	.long	L(11bytes) - L(table_32bytes)
	.long	L(12bytes) - L(table_32bytes)
	.long	L(13bytes) - L(table_32bytes)
	.long	L(14bytes) - L(table_32bytes)
	.long	L(15bytes) - L(table_32bytes)
	.long	L(16bytes) - L(table_32bytes)
	.long	L(17bytes) - L(table_32bytes)
	.long	L(18bytes) - L(table_32bytes)
	.long	L(19bytes) - L(table_32bytes)
	.long	L(20bytes) - L(table_32bytes)
	.long	L(21bytes) - L(table_32bytes)
	.long	L(22bytes) - L(table_32bytes)
	.long	L(23bytes) - L(table_32bytes)
	.long	L(24bytes) - L(table_32bytes)
	.long	L(25bytes) - L(table_32bytes)
	.long	L(26bytes) - L(table_32bytes)
	.long	L(27bytes) - L(table_32bytes)
	.long	L(28bytes) - L(table_32bytes)
	.long	L(29bytes) - L(table_32bytes)
	.long	L(30bytes) - L(table_32bytes)
	.long	L(31bytes) - L(table_32bytes)


#undef bcmp
weak_alias (BP_SYM (memcmp), BP_SYM (bcmp))
libc_hidden_builtin_def (BP_SYM (memcmp))