/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* Fast strcmp. This works one int at a time, using aligned pointers
* if possible, misaligned pointers if necessary. To avoid taking
* faults from going off the end of a page, the code is careful to go
* a byte-at-a-time when a misaligned pointer is near a page boundary.
* The code is almost portable, but see the assumptions below.
*/
/*
* ASSUMPTIONS:
* sizeof (int) is not greater than 8.
* sizeof (int) is a power of 2.
* An int pointer can always be dereferenced even if it is not properly
* aligned (though aligned references are assumed to be faster).
* It is OK to assign bogus values to a pointer (in particular, a
* value that is before the beginning of the string) as long as that
* pointer is only used with indices big enough to bring us back into
* the string.
* It is OK to reference bytes past the end of a string as long as we
* don't cross a page boundary.
*/
#include "lint.h"
#include <limits.h>
#include <unistd.h>
#include <sys/sysconfig.h>
#include "libc.h"
/*
* This strange expression will test to see if *any* byte in the int is
* a NUL. The constants are big enough to allow for ints up to 8 bytes.
* The two arguments are actually two copies of the same value; this
* allows the compiler freedom to play with both values for efficiency.
*/
(int)0x8080808080808080ULL)
int
{
int count;
static int pagesize;
return (0);
/*
* Go 1 byte at a time until at least one pointer is word aligned.
* Assumes that sizeof (int) is a power of 2.
*/
while ((((int) str1) & (sizeof (int) - 1)) &&
(((int) str2) & (sizeof (int) - 1))) {
if (*str1 == '\0')
return (0);
++str1;
++str2;
}
/*
* If one pointer is misaligned, we must be careful not to
* dereference it when it points across a page boundary.
* If we did, we might go past the end of the segment and
* get a SIGSEGV. Set "count" to the number of ints we can
* scan before running into such a boundary.
*/
if (((int) str1) & (sizeof (int) - 1)) {
if (pagesize == 0)
sizeof (int);
} else if (((int) str2) & (sizeof (int) - 1)) {
if (pagesize == 0)
sizeof (int);
}
/*
* Go "sizeof (int)" bytes at a time until at least one pointer
* is word aligned.
*
* Unwrap the loop for even a bit more speed.
*/
for (;;) {
/*
* Check whether we can test the next 4 ints without
* hitting a page boundary. If we can only test 1, 2,
* or 3, go and do that first. If we can't check any
* more, go and test one byte, realign, and start again.
*/
count -= 4;
switch (count) {
case -1:
--s1;
--s2;
goto do3; /* check only 3 ints */
case -2:
s1 -= 2;
s2 -= 2;
goto do2; /* check only 2 ints */
case -3:
s1 -= 3;
s2 -= 3;
goto do1; /* check only 1 int */
case -4:
case -5: /* -5, -6, and -7 come up on the */
case -6: /* next time around after we do one */
case -7: /* of the 3 gotos above */
goto one_byte;
/*
* The goto above should be explained. By going
* into the middle of the loop, it makes sure
* that we advance at least one byte. We will
* stay in that loop until the misaligned pointer
* becomes aligned (at the page boundary). We
* will then break out of that loop with the
* formerly misaligned pointer now aligned, the
* formerly aligned pointer now misaligned, and
* we will come back into this loop until the
* latter pointer reaches a page boundary.
*/
default: /* at least 4 ints to go */
break;
}
break;
return (0);
do3:
break;
return (0);
do2:
break;
return (0);
do1:
break;
return (0);
s1 += 4;
s2 += 4;
}
/* We found a difference. Go one byte at a time to find where. */
if (*str1 == '\0')
return (0);
++str1;
++str2;
}
}