memcmp(), memcmp

Compare the bytes in two buffers

Synopsis:

#include <string.h>

int memcmp( const void* s1,
            const void* s2,
            size_t length );

int memcmp_isr( const void* s1,
                const void* s2,
                size_t length );

Arguments:

s1, s2: Pointers to the buffers that you want to compare.
length: The number of bytes that you want to compare.

Library:

libc

Use the -l c option to qcc to link against this library. This library is usually included automatically.

Description:

The memcmp() function compares length bytes of the buffer pointed to by s1 to the buffer pointed to by s2.

The memcmp_isr() function does the same thing, but avoids using special-purpose registers (e.g., sse2) that incur additional cost when their state is saved during context switches. The relative performance of a process using this first or second function can be better or worse depending on the frequency and sizes of memory-copying operations, the specific target, and what other processes are doing. If memory copying does not play a major role in the process's overall performance, which function is faster isn't so important. Otherwise, developers are strongly encouraged to do their own testing and select the correct function.

In this release, both memcmp() and memcmp_isr() are safe to call from an interrupt handler.

Returns:

< 0: The object pointed to by s1 is less than the object pointed to by s2.
0: The object pointed to by s1 is equal to the object pointed to by s2.
> 0: The object pointed to by s1 is greater than the object pointed to by s2.

Examples:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main( void )
{
    char buffer[80];
    int retval;

    strcpy( buffer, "World" );
    
    retval = memcmp( buffer, "hello", 5 );
    if( retval < 0 ) {
        printf( "Less than\n" );
    } else if( retval == 0 ) {
        printf( "Equal to\n");
    } else {
        printf( "Greater than\n");
    }
    
    return EXIT_SUCCESS;
}

produces the output:

Less than

Environment variables:

LIBC_STRINGS

On certain targets, you can use this environment variable to select the implementation of memcmp(). It doesn't affect the implementation of memcmp_isr(). The value is one of the strings given below.

for AArch64 targets:
- aarch64_neon — optimized for AARCH64 targets using NEON
- generic — the default
for ARMv7 targets:
- cortex_a9 — optimized for the ARM Cortex-A9 processor; assumes that no unaligned access is supported
- cortex_a9_aligned — optimized for ARM Cortex-A9; requires that unaligned memory access be enabled on the platform. If memory access is misaligned, this implementation falls back to the NEON version.
- cortex_a9_neon — optimized for ARM Cortex-A9 using NEON
- generic — the default
- krait — optimized for the Qualcomm Krait CPU
- krait_neon — optimized for Qualcomm Krait using NEON

Processes that register ISRs shouldn't use the NEON versions.

Classification:

memcmp() is ANSI, POSIX 1003.1; memcmp_isr() is QNX Neutrino.

Safety:
Cancellation point	No
Interrupt handler	Yes
Signal handler	Yes
Thread	Yes

memcmp(), memcmp_isr()