packages/language/c/libc/string/v2_0/src/memcmp.cxx

   1 //===========================================================================
   2 //
   3 //      memcmp.cxx
   4 //
   5 //      ANSI standard memcmp() routine
   6 //
   7 //===========================================================================
   8 //####ECOSGPLCOPYRIGHTBEGIN####
   9 // -------------------------------------------
  10 // This file is part of eCos, the Embedded Configurable Operating System.
  11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  12 //
  13 // eCos is free software; you can redistribute it and/or modify it under
  14 // the terms of the GNU General Public License as published by the Free
  15 // Software Foundation; either version 2 or (at your option) any later version.
  16 //
  17 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20 // for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License along
  23 // with eCos; if not, write to the Free Software Foundation, Inc.,
  24 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25 //
  26 // As a special exception, if other files instantiate templates or use macros
  27 // or inline functions from this file, or you compile this file and link it
  28 // with other works to produce a work based on this file, this file does not
  29 // by itself cause the resulting work to be covered by the GNU General Public
  30 // License. However the source code for this file must still be made available
  31 // in accordance with section (3) of the GNU General Public License.
  32 //
  33 // This exception does not invalidate any other reasons why a work based on
  34 // this file might be covered by the GNU General Public License.
  35 //
  36 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  37 // at http://sources.redhat.com/ecos/ecos-license/
  38 // -------------------------------------------
  39 //####ECOSGPLCOPYRIGHTEND####
  40 //===========================================================================
  41 //#####DESCRIPTIONBEGIN####
  42 //
  43 // Author(s):     jlarmour
  44 // Contributors:
  45 // Date:          2000-04-14
  46 // Purpose:
  47 // Description:
  48 // Usage:
  49 //
  50 //####DESCRIPTIONEND####
  51 //
  52 //===========================================================================
  53
  54 // CONFIGURATION
  55
  56 #include <pkgconf/libc_string.h>   // Configuration header
  57
  58 // INCLUDES
  59
  60 #include <cyg/infra/cyg_type.h>    // Common type definitions
  61 #include <cyg/infra/cyg_trac.h>    // Tracing support
  62 #include <cyg/infra/cyg_ass.h>     // Assertion support
  63 #include <string.h>                // Header for this file
  64 #include <stddef.h>           // Compiler definitions such as size_t, NULL etc.
  65 #include <cyg/libc/string/stringsupp.hxx> // Useful string function support and
  66                                           // prototypes
  67
  68
  69 // EXPORTED SYMBOLS
  70
  71 externC int
  72 memcmp( const void *s1, const void *s2, size_t n ) \
  73     CYGBLD_ATTRIB_WEAK_ALIAS(__memcmp);
  74
  75 // FUNCTIONS
  76
  77 int
  78 __memcmp( const void *s1, const void *s2, size_t n )
  79 {
  80     int retval;
  81
  82     CYG_REPORT_FUNCNAMETYPE( "__memcmp", "returning %d" );
  83     CYG_REPORT_FUNCARG3( "s1=%08x, s2=%08x, n=%d", s1, s2, n );
  84
  85     if (n)
  86     {
  87         CYG_CHECK_DATA_PTR( s1, "s1 is not a valid pointer!" );
  88         CYG_CHECK_DATA_PTR( s2, "s2 is not a valid pointer!" );
  89     }
  90
  91 #if defined(CYGIMP_LIBC_STRING_PREFER_SMALL_TO_FAST) || defined(__OPTIMIZE_SIZE__)
  92     const unsigned char *m1 = (const unsigned char *) s1;
  93     const unsigned char *m2 = (const unsigned char *) s2;
  94
  95     while (n--)
  96     {
  97         if (*m1 != *m2)
  98         {
  99             retval = *m1 - *m2;
 100             CYG_REPORT_RETVAL( retval );
 101             return retval;
 102         }
 103         m1++;
 104         m2++;
 105     }
 106     CYG_REPORT_RETVAL( 0 );
 107     return 0;
 108 #else
 109     const unsigned char *m1 = (const unsigned char *) s1;
 110     const unsigned char *m2 = (const unsigned char *) s2;
 111     const CYG_WORD *aligned_m1;
 112     const CYG_WORD *aligned_m2;
 113
 114     // If the size is too small, or either pointer is unaligned,
 115     // then we punt to the byte compare loop.  Hopefully this will
 116     // not turn up in inner loops.
 117     if (CYG_LIBC_STR_OPT_TOO_SMALL(n) || CYG_LIBC_STR_UNALIGNED2(m1,m2))
 118     {
 119         while (n--)
 120         {
 121             if (*m1 != *m2)
 122             {
 123                 retval = *m1 - *m2;
 124                 CYG_REPORT_RETVAL( retval );
 125                 return retval;
 126             }
 127             m1++;
 128             m2++;
 129         }
 130         CYG_REPORT_RETVAL( 0 );
 131         return 0;
 132     }
 133
 134     // Otherwise, load and compare the blocks of memory one
 135     // word at a time.
 136     aligned_m1 = (const CYG_WORD *) m1;
 137     aligned_m2 = (const CYG_WORD *) m2;
 138     while (n > CYG_LIBC_STR_OPT_LITTLEBLOCKSIZE)
 139     {
 140         if (*aligned_m1 != *aligned_m2)
 141         {
 142             // This block of characters has a mismatch, somewhere.
 143             // xoring them together and then testing for null would
 144             // be fastest, but this is clearer code.
 145             m1 = (const unsigned char *)aligned_m1;
 146             m2 = (const unsigned char *)aligned_m2;
 147             while (n--)
 148             {
 149                 if (*m1 != *m2)
 150                 {
 151                     retval = *m1 - *m2;
 152                     CYG_REPORT_RETVAL( retval );
 153                     return retval;
 154                 }
 155                 m1++;
 156                 m2++;
 157             }
 158             // NOT REACHED
 159         }
 160         aligned_m1++;
 161         aligned_m2++;
 162         n -= CYG_LIBC_STR_OPT_LITTLEBLOCKSIZE;
 163     }
 164
 165     // checking the last few characters
 166
 167     m1 = (const unsigned char *)aligned_m1;
 168     m2 = (const unsigned char *)aligned_m2;
 169
 170     while (n--)
 171     {
 172         if (*m1 != *m2)
 173         {
 174             retval = *m1 - *m2;
 175             CYG_REPORT_RETVAL( retval );
 176             return retval;
 177         }
 178         m1++;
 179         m2++;
 180     }
 181
 182     CYG_REPORT_RETVAL( 0 );
 183     return 0;
 184 #endif // not defined(CYGIMP_LIBC_STRING_PREFER_SMALL_TO_FAST) ||
 185        //     defined(__OPTIMIZE_SIZE__)
 186 } // __memcmp()
 187
 188 // EOF memcmp.cxx