/*
Copyright (c) 1994 Cygnus Support.
All rights reserved.

Redistribution and use in source and binary forms are permitted
provided that the above copyright notice and this paragraph are
duplicated in all such forms and that any documentation,
and/or other materials related to such
distribution and use acknowledge that the software was developed
at Cygnus Support, Inc.  Cygnus Support, Inc. may not be used to
endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */
/*
FUNCTION
        <<memcmp>>---compare two memory areas

INDEX
        memcmp

SYNOPSIS
        #include <string.h>
        int memcmp(const void *<[s1]>, const void *<[s2]>, size_t <[n]>);

DESCRIPTION
        This function compares not more than <[n]> characters of the
        object pointed to by <[s1]> with the object pointed to by <[s2]>.


RETURNS
        The function returns an integer greater than, equal to or
        less than zero 	according to whether the object pointed to by
        <[s1]> is greater than, equal to or less than the object
        pointed to by <[s2]>.

PORTABILITY
<<memcmp>> is ANSI C.

<<memcmp>> requires no supporting OS subroutines.

QUICKREF
        memcmp ansi pure
*/

#include <string.h>
#include "local.h"

int
memcmp(const void *m1, const void *m2, size_t n)
{
#if defined(__PREFER_SIZE_OVER_SPEED) || defined(__OPTIMIZE_SIZE__)
    unsigned char *s1 = (unsigned char *)m1;
    unsigned char *s2 = (unsigned char *)m2;

    while (n--) {
        if (*s1 != *s2) {
            return *s1 - *s2;
        }
        s1++;
        s2++;
    }
    return 0;
#else
    unsigned char *s1 = (unsigned char *)m1;
    unsigned char *s2 = (unsigned char *)m2;
    unsigned long *a1;
    unsigned long *a2;

    /* If the size is too small, or either pointer is unaligned,
       then we punt to the byte compare loop.  Hopefully this will
       not turn up in inner loops.  */
    if (!TOO_SMALL_LITTLE_BLOCK(n) && !UNALIGNED_X_Y(s1, s2)) {
        /* Otherwise, load and compare the blocks of memory one
           word at a time.  */
        a1 = (unsigned long *)s1;
        a2 = (unsigned long *)s2;
        while (!TOO_SMALL_LITTLE_BLOCK(n)) {
            if (*a1 != *a2)
                break;
            a1++;
            a2++;
            n -= LITTLE_BLOCK_SIZE;
        }

        /* check m mod LITTLE_BLOCK_SIZE remaining characters */

        s1 = (unsigned char *)a1;
        s2 = (unsigned char *)a2;
    }

    while (n--) {
        if (*s1 != *s2)
            return *s1 - *s2;
        s1++;
        s2++;
    }

    return 0;
#endif /* not __PREFER_SIZE_OVER_SPEED */
}
