shared/vg_replace_strmem.c

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- Replacements for strcpy(), memcpy() et al, which run on the  ---*/
   4 /*--- simulated CPU.                                               ---*/
   5 /*---                                          vg_replace_strmem.c ---*/
   6 /*--------------------------------------------------------------------*/
   7
   8 /*
   9    This file is part of Valgrind.
  10
  11    Copyright (C) 2000-2015 Julian Seward
  12       jseward@acm.org
  13
  14    This program is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation; either version 2 of the
  17    License, or (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful, but
  20    WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22    General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  27    02111-1307, USA.
  28
  29    The GNU General Public License is contained in the file COPYING.
  30 */
  31
  32 #include "pub_tool_basics.h"
  33 #include "pub_tool_poolalloc.h"
  34 #include "pub_tool_hashtable.h"
  35 #include "pub_tool_redir.h"
  36 #include "pub_tool_tooliface.h"
  37 #include "pub_tool_clreq.h"
  38
  39 /* ---------------------------------------------------------------------
  40    We have our own versions of these functions for two reasons:
  41    (a) it allows us to do overlap checking
  42    (b) some of the normal versions are hyper-optimised, which fools
  43        Memcheck and cause spurious value warnings.  Our versions are
  44        simpler.
  45    (c) the glibc SSE-variants can read past the end of the input data
  46        ranges. This can cause false-positive Memcheck / Helgrind / DRD
  47        reports.
  48
  49    Note that overenthusiastic use of PLT bypassing by the glibc people also
  50    means that we need to patch multiple versions of some of the functions to
  51    our own implementations.
  52
  53    THEY RUN ON THE SIMD CPU!
  54    ------------------------------------------------------------------ */
  55
  56 /* Assignment of behavioural equivalence class tags: 2NNNP is intended
  57    to be reserved for str/mem intercepts.  Current usage:
  58
  59    20010 STRRCHR
  60    20020 STRCHR
  61    20030 STRCAT
  62    20040 STRNCAT
  63    20050 STRLCAT
  64    20060 STRNLEN
  65    20070 STRLEN
  66    20080 STRCPY
  67    20090 STRNCPY
  68    20100 STRLCPY
  69    20110 STRNCMP
  70    20120 STRCASECMP
  71    20130 STRNCASECMP
  72    20140 STRCASECMP_L
  73    20150 STRNCASECMP_L
  74    20160 STRCMP
  75    20170 MEMCHR
  76
  77    20180 MEMCPY    if there's a conflict between memcpy and
  78    20181 MEMMOVE   memmove, prefer memmove
  79
  80    20190 MEMCMP
  81    20200 STPCPY
  82    20210 MEMSET
  83    2022P unused (was previously MEMMOVE)
  84    20230 BCOPY
  85    20240 GLIBC25___MEMMOVE_CHK
  86    20250 GLIBC232_STRCHRNUL
  87    20260 GLIBC232_RAWMEMCHR
  88    20270 GLIBC25___STRCPY_CHK
  89    20280 GLIBC25___STPCPY_CHK
  90    20290 GLIBC25_MEMPCPY
  91    20300 GLIBC26___MEMCPY_CHK
  92    20310 STRSTR
  93    20320 STRPBRK
  94    20330 STRCSPN
  95    20340 STRSPN
  96    20350 STRCASESTR
  97    20360 MEMRCHR
  98    20370 WCSLEN
  99    20380 WCSCMP
 100    20390 WCSCPY
 101    20400 WCSCHR
 102    20410 WCSRCHR
 103    20420 STPNCPY
 104 */
 105
 106 #if defined(VGO_solaris)
 107 /*
 108    Detour functions in the libc and the runtime linker. If a function isn't
 109    much optimized (and no overlap checking is necessary) then redir the
 110    function only in the libc. This way we can keep stacktraces in the tests
 111    consistent.
 112 */
 113 #endif
 114
 115
 116 /* Figure out if [dst .. dst+dstlen-1] overlaps with
 117                  [src .. src+srclen-1].
 118    We assume that the address ranges do not wrap around
 119    (which is safe since on Linux addresses >= 0xC0000000
 120    are not accessible and the program will segfault in this
 121    circumstance, presumably).
 122 */
 123 static inline
 124 Bool is_overlap ( void* dst, const void* src, SizeT dstlen, SizeT srclen )
 125 {
 126    Addr loS, hiS, loD, hiD;
 127
 128    if (dstlen == 0 || srclen == 0)
 129       return False;
 130
 131    loS = (Addr)src;
 132    loD = (Addr)dst;
 133    hiS = loS + srclen - 1;
 134    hiD = loD + dstlen - 1;
 135
 136    /* So figure out if [loS .. hiS] overlaps with [loD .. hiD]. */
 137    if (loS < loD) {
 138       return !(hiS < loD);
 139    }
 140    else if (loD < loS) {
 141       return !(hiD < loS);
 142    }
 143    else {
 144       /* They start at same place.  Since we know neither of them has
 145          zero length, they must overlap. */
 146       return True;
 147    }
 148 }
 149
 150
 151 /* Call here to exit if we can't continue.  On Android we can't call
 152    _exit for some reason, so we have to blunt-instrument it. */
 153 __attribute__ ((__noreturn__))
 154 static inline void my_exit ( int x )
 155 {
 156 #  if defined(VGPV_arm_linux_android) || defined(VGPV_mips32_linux_android) \
 157       || defined(VGPV_arm64_linux_android)
 158    __asm__ __volatile__(".word 0xFFFFFFFF");
 159    while (1) {}
 160 #  elif defined(VGPV_x86_linux_android)
 161    __asm__ __volatile__("ud2");
 162    while (1) {}
 163 #  else
 164    extern __attribute__ ((__noreturn__)) void _exit(int status);
 165    _exit(x);
 166 #  endif
 167 }
 168
 169
 170 // This is a macro rather than a function because we don't want to have an
 171 // extra function in the stack trace.
 172 #ifndef RECORD_OVERLAP_ERROR
 173 #define RECORD_OVERLAP_ERROR(s, src, dst, len) do { } while (0)
 174 #endif
 175 #ifndef VALGRIND_CHECK_VALUE_IS_DEFINED
 176 #define VALGRIND_CHECK_VALUE_IS_DEFINED(__lvalue) 1
 177 #endif
 178
 179
 180 /*---------------------- strrchr ----------------------*/
 181
 182 #define STRRCHR(soname, fnname) \
 183    char* VG_REPLACE_FUNCTION_EZU(20010,soname,fnname)( const char* s, int c ); \
 184    char* VG_REPLACE_FUNCTION_EZU(20010,soname,fnname)( const char* s, int c ) \
 185    { \
 186       HChar ch = (HChar)c;   \
 187       const HChar* p = s;       \
 188       const HChar* last = NULL; \
 189       while (True) { \
 190          if (*p == ch) last = p; \
 191          if (*p == 0) return CONST_CAST(HChar *,last);    \
 192          p++; \
 193       } \
 194    }
 195
 196 // Apparently rindex() is the same thing as strrchr()
 197 #if defined(VGO_linux)
 198  STRRCHR(VG_Z_LIBC_SONAME,   strrchr)
 199  STRRCHR(VG_Z_LIBC_SONAME,   rindex)
 200  STRRCHR(VG_Z_LIBC_SONAME,   __GI_strrchr)
 201  STRRCHR(VG_Z_LIBC_SONAME,   __strrchr_sse2)
 202  STRRCHR(VG_Z_LIBC_SONAME,   __strrchr_sse2_no_bsf)
 203  STRRCHR(VG_Z_LIBC_SONAME,   __strrchr_sse42)
 204  STRRCHR(VG_Z_LD_LINUX_SO_2, rindex)
 205 #if defined(VGPV_arm_linux_android) || defined(VGPV_x86_linux_android) \
 206     || defined(VGPV_mips32_linux_android)
 207   STRRCHR(NONE, __dl_strrchr); /* in /system/bin/linker */
 208 #endif
 209
 210 #elif defined(VGO_darwin)
 211  //STRRCHR(VG_Z_LIBC_SONAME,   strrchr)
 212  //STRRCHR(VG_Z_LIBC_SONAME,   rindex)
 213  //STRRCHR(VG_Z_DYLD,          strrchr)
 214  //STRRCHR(VG_Z_DYLD,          rindex)
 215  STRRCHR(VG_Z_LIBC_SONAME, strrchr)
 216 # if DARWIN_VERS >= DARWIN_10_9
 217   STRRCHR(libsystemZucZddylib, strrchr)
 218 # endif
 219
 220 #elif defined(VGO_solaris)
 221  STRRCHR(VG_Z_LIBC_SONAME,   strrchr)
 222  STRRCHR(VG_Z_LIBC_SONAME,   rindex)
 223  STRRCHR(VG_Z_LD_SO_1,       strrchr)
 224
 225 #endif
 226
 227
 228 /*---------------------- strchr ----------------------*/
 229
 230 #define STRCHR(soname, fnname) \
 231    char* VG_REPLACE_FUNCTION_EZU(20020,soname,fnname) ( const char* s, int c ); \
 232    char* VG_REPLACE_FUNCTION_EZU(20020,soname,fnname) ( const char* s, int c ) \
 233    { \
 234       HChar  ch = (HChar)c ; \
 235       const HChar* p  = s;   \
 236       while (True) { \
 237          if (*p == ch) return CONST_CAST(HChar *,p);  \
 238          if (*p == 0) return NULL; \
 239          p++; \
 240       } \
 241    }
 242
 243 // Apparently index() is the same thing as strchr()
 244 #if defined(VGO_linux)
 245  STRCHR(VG_Z_LIBC_SONAME,          strchr)
 246  STRCHR(VG_Z_LIBC_SONAME,          __GI_strchr)
 247  STRCHR(VG_Z_LIBC_SONAME,          __strchr_sse2)
 248  STRCHR(VG_Z_LIBC_SONAME,          __strchr_sse2_no_bsf)
 249  STRCHR(VG_Z_LIBC_SONAME,          index)
 250 # if !defined(VGP_x86_linux)
 251   STRCHR(VG_Z_LD_LINUX_SO_2,        strchr)
 252   STRCHR(VG_Z_LD_LINUX_SO_2,        index)
 253   STRCHR(VG_Z_LD_LINUX_X86_64_SO_2, strchr)
 254   STRCHR(VG_Z_LD_LINUX_X86_64_SO_2, index)
 255 # endif
 256
 257 #elif defined(VGO_darwin)
 258  STRCHR(VG_Z_LIBC_SONAME, strchr)
 259 # if DARWIN_VERS == DARWIN_10_9
 260   STRCHR(libsystemZuplatformZddylib, _platform_strchr)
 261 # endif
 262 # if DARWIN_VERS >= DARWIN_10_10
 263   /* _platform_strchr$VARIANT$Generic */
 264   STRCHR(libsystemZuplatformZddylib, _platform_strchr$VARIANT$Generic)
 265   /* _platform_strchr$VARIANT$Haswell */
 266   STRCHR(libsystemZuplatformZddylib, _platform_strchr$VARIANT$Haswell)
 267 # endif
 268
 269 #elif defined(VGO_solaris)
 270  STRCHR(VG_Z_LIBC_SONAME,          strchr)
 271  STRCHR(VG_Z_LIBC_SONAME,          index)
 272  STRCHR(VG_Z_LD_SO_1,              strchr)
 273
 274 #endif
 275
 276
 277 /*---------------------- strcat ----------------------*/
 278
 279 #define STRCAT(soname, fnname) \
 280    char* VG_REPLACE_FUNCTION_EZU(20030,soname,fnname) \
 281             ( char* dst, const char* src ); \
 282    char* VG_REPLACE_FUNCTION_EZU(20030,soname,fnname) \
 283             ( char* dst, const char* src ) \
 284    { \
 285       const HChar* src_orig = src; \
 286             HChar* dst_orig = dst; \
 287       while (*dst) dst++; \
 288       while (*src) *dst++ = *src++; \
 289       *dst = 0; \
 290       \
 291       /* This is a bit redundant, I think;  any overlap and the strcat will */ \
 292       /* go forever... or until a seg fault occurs. */ \
 293       if (is_overlap(dst_orig,  \
 294                      src_orig,  \
 295                      (Addr)dst-(Addr)dst_orig+1,  \
 296                      (Addr)src-(Addr)src_orig+1)) \
 297          RECORD_OVERLAP_ERROR("strcat", dst_orig, src_orig, 0); \
 298       \
 299       return dst_orig; \
 300    }
 301
 302 #if defined(VGO_linux)
 303  STRCAT(VG_Z_LIBC_SONAME, strcat)
 304  STRCAT(VG_Z_LIBC_SONAME, __GI_strcat)
 305
 306 #elif defined(VGO_darwin)
 307  //STRCAT(VG_Z_LIBC_SONAME, strcat)
 308
 309 #elif defined(VGO_solaris)
 310  STRCAT(VG_Z_LIBC_SONAME, strcat)
 311  STRCAT(VG_Z_LD_SO_1,     strcat)
 312
 313 #endif
 314
 315
 316 /*---------------------- strncat ----------------------*/
 317
 318 #define STRNCAT(soname, fnname) \
 319    char* VG_REPLACE_FUNCTION_EZU(20040,soname,fnname) \
 320             ( char* dst, const char* src, SizeT n ); \
 321    char* VG_REPLACE_FUNCTION_EZU(20040,soname,fnname) \
 322             ( char* dst, const char* src, SizeT n ) \
 323    { \
 324       const HChar* src_orig = src; \
 325             HChar* dst_orig = dst; \
 326       SizeT m = 0; \
 327       \
 328       while (*dst) dst++; \
 329       while (m < n && *src) { m++; *dst++ = *src++; } /* concat <= n chars */ \
 330       *dst = 0;                                       /* always add null   */ \
 331       \
 332       /* This checks for overlap after copying, unavoidable without */ \
 333       /* pre-counting lengths... should be ok */ \
 334       if (is_overlap(dst_orig,  \
 335                      src_orig,  \
 336                      (Addr)dst-(Addr)dst_orig+1, \
 337                      (Addr)src-(Addr)src_orig+1)) \
 338          RECORD_OVERLAP_ERROR("strncat", dst_orig, src_orig, n); \
 339       \
 340       return dst_orig; \
 341    }
 342
 343 #if defined(VGO_linux)
 344  STRNCAT(VG_Z_LIBC_SONAME, strncat)
 345
 346 #elif defined(VGO_darwin)
 347  //STRNCAT(VG_Z_LIBC_SONAME, strncat)
 348  //STRNCAT(VG_Z_DYLD,        strncat)
 349
 350 #elif defined(VGO_solaris)
 351  STRNCAT(VG_Z_LIBC_SONAME, strncat)
 352
 353 #endif
 354
 355
 356 /*---------------------- strlcat ----------------------*/
 357
 358 /* Append src to dst. n is the size of dst's buffer. dst is guaranteed
 359    to be nul-terminated after the copy, unless n <= strlen(dst_orig).
 360    Returns min(n, strlen(dst_orig)) + strlen(src_orig).
 361    Truncation occurred if retval >= n.
 362 */
 363 #define STRLCAT(soname, fnname) \
 364    SizeT VG_REPLACE_FUNCTION_EZU(20050,soname,fnname) \
 365         ( char* dst, const char* src, SizeT n ); \
 366    SizeT VG_REPLACE_FUNCTION_EZU(20050,soname,fnname) \
 367         ( char* dst, const char* src, SizeT n ) \
 368    { \
 369       const HChar* src_orig = src; \
 370       HChar* dst_orig = dst; \
 371       SizeT m = 0; \
 372       \
 373       while (m < n && *dst) { m++; dst++; } \
 374       if (m < n) { \
 375          /* Fill as far as dst_orig[n-2], then nul-terminate. */ \
 376          while (m < n-1 && *src) { m++; *dst++ = *src++; } \
 377          *dst = 0; \
 378       } else { \
 379          /* No space to copy anything to dst. m == n */ \
 380       } \
 381       /* Finish counting min(n, strlen(dst_orig)) + strlen(src_orig) */ \
 382       while (*src) { m++; src++; } \
 383       /* This checks for overlap after copying, unavoidable without */ \
 384       /* pre-counting lengths... should be ok */ \
 385       if (is_overlap(dst_orig,  \
 386                      src_orig,  \
 387                      (Addr)dst-(Addr)dst_orig+1,  \
 388                      (Addr)src-(Addr)src_orig+1)) \
 389          RECORD_OVERLAP_ERROR("strlcat", dst_orig, src_orig, n); \
 390       \
 391       return m; \
 392    }
 393
 394 #if defined(VGO_linux)
 395
 396 #elif defined(VGO_darwin)
 397  //STRLCAT(VG_Z_LIBC_SONAME, strlcat)
 398  //STRLCAT(VG_Z_DYLD,        strlcat)
 399  STRLCAT(VG_Z_LIBC_SONAME, strlcat)
 400
 401 #elif defined(VGO_solaris)
 402  STRLCAT(VG_Z_LIBC_SONAME, strlcat)
 403
 404 #endif
 405
 406
 407 /*---------------------- strnlen ----------------------*/
 408
 409 #define STRNLEN(soname, fnname) \
 410    SizeT VG_REPLACE_FUNCTION_EZU(20060,soname,fnname) \
 411             ( const char* str, SizeT n ); \
 412    SizeT VG_REPLACE_FUNCTION_EZU(20060,soname,fnname) \
 413             ( const char* str, SizeT n ) \
 414    { \
 415       SizeT i = 0; \
 416       while (i < n && str[i] != 0) i++; \
 417       return i; \
 418    }
 419
 420 #if defined(VGO_linux)
 421  STRNLEN(VG_Z_LIBC_SONAME, strnlen)
 422  STRNLEN(VG_Z_LIBC_SONAME, __GI_strnlen)
 423
 424 #elif defined(VGO_darwin)
 425 # if DARWIN_VERS == DARWIN_10_9
 426   STRNLEN(libsystemZucZddylib, strnlen)
 427 # endif
 428
 429 #elif defined(VGO_solaris)
 430  STRNLEN(VG_Z_LIBC_SONAME, strnlen)
 431
 432 #endif
 433
 434
 435 /*---------------------- strlen ----------------------*/
 436
 437 // Note that this replacement often doesn't get used because gcc inlines
 438 // calls to strlen() with its own built-in version.  This can be very
 439 // confusing if you aren't expecting it.  Other small functions in
 440 // this file may also be inline by gcc.
 441
 442 #define STRLEN(soname, fnname) \
 443    SizeT VG_REPLACE_FUNCTION_EZU(20070,soname,fnname) \
 444       ( const char* str ); \
 445    SizeT VG_REPLACE_FUNCTION_EZU(20070,soname,fnname) \
 446       ( const char* str )  \
 447    { \
 448       SizeT i = 0; \
 449       while (str[i] != 0) i++; \
 450       return i; \
 451    }
 452
 453 #if defined(VGO_linux)
 454  STRLEN(VG_Z_LIBC_SONAME,          strlen)
 455  STRLEN(VG_Z_LIBC_SONAME,          __GI_strlen)
 456  STRLEN(VG_Z_LIBC_SONAME,          __strlen_sse2)
 457  STRLEN(VG_Z_LIBC_SONAME,          __strlen_sse2_no_bsf)
 458  STRLEN(VG_Z_LIBC_SONAME,          __strlen_sse42)
 459  STRLEN(VG_Z_LD_LINUX_SO_2,        strlen)
 460  STRLEN(VG_Z_LD_LINUX_X86_64_SO_2, strlen)
 461 # if defined(VGPV_arm_linux_android) \
 462      || defined(VGPV_x86_linux_android) \
 463      || defined(VGPV_mips32_linux_android)
 464   STRLEN(NONE, __dl_strlen); /* in /system/bin/linker */
 465 # endif
 466
 467 #elif defined(VGO_darwin)
 468  STRLEN(VG_Z_LIBC_SONAME, strlen)
 469 # if DARWIN_VERS >= DARWIN_10_9
 470   STRLEN(libsystemZucZddylib, strlen)
 471 # endif
 472
 473 #elif defined(VGO_solaris)
 474  STRLEN(VG_Z_LIBC_SONAME,          strlen)
 475  STRLEN(VG_Z_LD_SO_1,              strlen)
 476
 477 #endif
 478
 479
 480 /*---------------------- strcpy ----------------------*/
 481
 482 #define STRCPY(soname, fnname) \
 483    char* VG_REPLACE_FUNCTION_EZU(20080,soname,fnname) \
 484       ( char* dst, const char* src ); \
 485    char* VG_REPLACE_FUNCTION_EZU(20080,soname,fnname) \
 486       ( char* dst, const char* src ) \
 487    { \
 488       const HChar* src_orig = src; \
 489             HChar* dst_orig = dst; \
 490       \
 491       while (*src) *dst++ = *src++; \
 492       *dst = 0; \
 493       \
 494       /* This checks for overlap after copying, unavoidable without */ \
 495       /* pre-counting length... should be ok */ \
 496       if (is_overlap(dst_orig,  \
 497                      src_orig,  \
 498                      (Addr)dst-(Addr)dst_orig+1, \
 499                      (Addr)src-(Addr)src_orig+1)) \
 500          RECORD_OVERLAP_ERROR("strcpy", dst_orig, src_orig, 0); \
 501       \
 502       return dst_orig; \
 503    }
 504
 505 #if defined(VGO_linux)
 506  STRCPY(VG_Z_LIBC_SONAME, strcpy)
 507  STRCPY(VG_Z_LIBC_SONAME, __GI_strcpy)
 508
 509 #elif defined(VGO_darwin)
 510  STRCPY(VG_Z_LIBC_SONAME, strcpy)
 511 # if DARWIN_VERS == DARWIN_10_9
 512   STRCPY(libsystemZucZddylib, strcpy)
 513 # endif
 514
 515 #elif defined(VGO_solaris)
 516  STRCPY(VG_Z_LIBC_SONAME, strcpy)
 517  STRCPY(VG_Z_LD_SO_1,     strcpy)
 518
 519 #endif
 520
 521
 522 /*---------------------- strncpy ----------------------*/
 523
 524 #define STRNCPY(soname, fnname) \
 525    char* VG_REPLACE_FUNCTION_EZU(20090,soname,fnname) \
 526             ( char* dst, const char* src, SizeT n ); \
 527    char* VG_REPLACE_FUNCTION_EZU(20090,soname,fnname) \
 528             ( char* dst, const char* src, SizeT n ) \
 529    { \
 530       const HChar* src_orig = src; \
 531             HChar* dst_orig = dst; \
 532       SizeT m = 0; \
 533       \
 534       while (m   < n && *src) { m++; *dst++ = *src++; } \
 535       /* Check for overlap after copying; all n bytes of dst are relevant, */ \
 536       /* but only m+1 bytes of src if terminator was found */ \
 537       if (is_overlap(dst_orig, src_orig, n, (m < n) ? m+1 : n)) \
 538          RECORD_OVERLAP_ERROR("strncpy", dst, src, n); \
 539       while (m++ < n) *dst++ = 0;         /* must pad remainder with nulls */ \
 540       \
 541       return dst_orig; \
 542    }
 543
 544 #if defined(VGO_linux)
 545  STRNCPY(VG_Z_LIBC_SONAME, strncpy)
 546  STRNCPY(VG_Z_LIBC_SONAME, __GI_strncpy)
 547  STRNCPY(VG_Z_LIBC_SONAME, __strncpy_sse2)
 548  STRNCPY(VG_Z_LIBC_SONAME, __strncpy_sse2_unaligned)
 549
 550 #elif defined(VGO_darwin)
 551  STRNCPY(VG_Z_LIBC_SONAME, strncpy)
 552 # if DARWIN_VERS >= DARWIN_10_9
 553   STRNCPY(libsystemZucZddylib, strncpy)
 554 # endif
 555
 556 #elif defined(VGO_solaris)
 557  STRNCPY(VG_Z_LIBC_SONAME, strncpy)
 558  STRNCPY(VG_Z_LD_SO_1,     strncpy)
 559
 560 #endif
 561
 562
 563 /*---------------------- strlcpy ----------------------*/
 564
 565 /* Copy up to n-1 bytes from src to dst. Then nul-terminate dst if n > 0.
 566    Returns strlen(src). Does not zero-fill the remainder of dst. */
 567 #define STRLCPY(soname, fnname) \
 568    SizeT VG_REPLACE_FUNCTION_EZU(20100,soname,fnname) \
 569        ( char* dst, const char* src, SizeT n ); \
 570    SizeT VG_REPLACE_FUNCTION_EZU(20100,soname,fnname) \
 571        ( char* dst, const char* src, SizeT n ) \
 572    { \
 573       const HChar* src_orig = src; \
 574       HChar* dst_orig = dst; \
 575       SizeT m = 0; \
 576       \
 577       STRLCPY_CHECK_FOR_DSTSIZE_ZERO \
 578       \
 579       while (m < n-1 && *src) { m++; *dst++ = *src++; } \
 580       /* m non-nul bytes have now been copied, and m <= n-1. */ \
 581       /* Check for overlap after copying; all n bytes of dst are relevant, */ \
 582       /* but only m+1 bytes of src if terminator was found */ \
 583       if (is_overlap(dst_orig, src_orig, n, (m < n) ? m+1 : n)) \
 584           RECORD_OVERLAP_ERROR("strlcpy", dst, src, n); \
 585       /* Nul-terminate dst. */ \
 586       if (n > 0) *dst = 0; \
 587       /* Finish counting strlen(src). */ \
 588       while (*src) src++; \
 589       return src - src_orig; \
 590    }
 591
 592 #if defined(VGO_linux)
 593
 594 #if defined(VGPV_arm_linux_android) || defined(VGPV_x86_linux_android) \
 595     || defined(VGPV_mips32_linux_android)
 596  #define STRLCPY_CHECK_FOR_DSTSIZE_ZERO
 597  STRLCPY(VG_Z_LIBC_SONAME, strlcpy);
 598 #endif
 599
 600 #elif defined(VGO_darwin)
 601  #define STRLCPY_CHECK_FOR_DSTSIZE_ZERO
 602  //STRLCPY(VG_Z_LIBC_SONAME, strlcpy)
 603  //STRLCPY(VG_Z_DYLD,        strlcpy)
 604  STRLCPY(VG_Z_LIBC_SONAME, strlcpy)
 605
 606 #elif defined(VGO_solaris)
 607  /* special case for n == 0 which is undocumented but heavily used */
 608  #define STRLCPY_CHECK_FOR_DSTSIZE_ZERO \
 609     if (n == 0) { \
 610        while (*src) src++; \
 611        return src - src_orig; \
 612     }
 613
 614  STRLCPY(VG_Z_LIBC_SONAME, strlcpy)
 615
 616 #endif
 617
 618
 619 /*---------------------- strncmp ----------------------*/
 620
 621 #define STRNCMP(soname, fnname) \
 622    int VG_REPLACE_FUNCTION_EZU(20110,soname,fnname) \
 623           ( const char* s1, const char* s2, SizeT nmax ); \
 624    int VG_REPLACE_FUNCTION_EZU(20110,soname,fnname) \
 625           ( const char* s1, const char* s2, SizeT nmax ) \
 626    { \
 627       SizeT n = 0; \
 628       while (True) { \
 629          if (n >= nmax) return 0; \
 630          if (*s1 == 0 && *s2 == 0) return 0; \
 631          if (*s1 == 0) return -1; \
 632          if (*s2 == 0) return 1; \
 633          \
 634          if (*(const UChar*)s1 < *(const UChar*)s2) return -1; \
 635          if (*(const UChar*)s1 > *(const UChar*)s2) return 1; \
 636          \
 637          s1++; s2++; n++; \
 638       } \
 639    }
 640
 641 #if defined(VGO_linux)
 642  STRNCMP(VG_Z_LIBC_SONAME, strncmp)
 643  STRNCMP(VG_Z_LIBC_SONAME, __GI_strncmp)
 644  STRNCMP(VG_Z_LIBC_SONAME, __strncmp_sse2)
 645  STRNCMP(VG_Z_LIBC_SONAME, __strncmp_sse42)
 646
 647 #elif defined(VGO_darwin)
 648  STRNCMP(VG_Z_LIBC_SONAME,        strncmp)
 649 # if DARWIN_VERS >= DARWIN_10_9
 650   STRNCMP(libsystemZuplatformZddylib, _platform_strncmp)
 651 # endif
 652
 653 #elif defined(VGO_solaris)
 654  STRNCMP(VG_Z_LIBC_SONAME, strncmp)
 655
 656 #endif
 657
 658
 659 /*---------------------- strcasecmp ----------------------*/
 660
 661 #define STRCASECMP(soname, fnname) \
 662    int VG_REPLACE_FUNCTION_EZU(20120,soname,fnname) \
 663           ( const char* s1, const char* s2 ); \
 664    int VG_REPLACE_FUNCTION_EZU(20120,soname,fnname) \
 665           ( const char* s1, const char* s2 ) \
 666    { \
 667       extern int tolower(int); \
 668       register UChar c1; \
 669       register UChar c2; \
 670       while (True) { \
 671          c1 = tolower(*(const UChar *)s1); \
 672          c2 = tolower(*(const UChar *)s2); \
 673          if (c1 != c2) break; \
 674          if (c1 == 0) break; \
 675          s1++; s2++; \
 676       } \
 677       if ((UChar)c1 < (UChar)c2) return -1; \
 678       if ((UChar)c1 > (UChar)c2) return 1; \
 679       return 0; \
 680    }
 681
 682 #if defined(VGO_linux)
 683 # if !defined(VGPV_arm_linux_android) \
 684      && !defined(VGPV_x86_linux_android) \
 685      && !defined(VGPV_mips32_linux_android) \
 686      && !defined(VGPV_arm64_linux_android)
 687   STRCASECMP(VG_Z_LIBC_SONAME, strcasecmp)
 688   STRCASECMP(VG_Z_LIBC_SONAME, __GI_strcasecmp)
 689 # endif
 690
 691 #elif defined(VGO_darwin)
 692  //STRCASECMP(VG_Z_LIBC_SONAME, strcasecmp)
 693
 694 #elif defined(VGO_solaris)
 695  STRCASECMP(VG_Z_LIBC_SONAME, strcasecmp)
 696
 697 #endif
 698
 699
 700 /*---------------------- strncasecmp ----------------------*/
 701
 702 #define STRNCASECMP(soname, fnname) \
 703    int VG_REPLACE_FUNCTION_EZU(20130,soname,fnname) \
 704           ( const char* s1, const char* s2, SizeT nmax ); \
 705    int VG_REPLACE_FUNCTION_EZU(20130,soname,fnname) \
 706           ( const char* s1, const char* s2, SizeT nmax ) \
 707    { \
 708       extern int tolower(int); \
 709       SizeT n = 0; \
 710       while (True) { \
 711          if (n >= nmax) return 0; \
 712          if (*s1 == 0 && *s2 == 0) return 0; \
 713          if (*s1 == 0) return -1; \
 714          if (*s2 == 0) return 1; \
 715          \
 716          if (tolower(*(const UChar *)s1) \
 717              < tolower(*(const UChar*)s2)) return -1; \
 718          if (tolower(*(const UChar *)s1) \
 719              > tolower(*(const UChar *)s2)) return 1; \
 720          \
 721          s1++; s2++; n++; \
 722       } \
 723    }
 724
 725 #if defined(VGO_linux)
 726 # if !defined(VGPV_arm_linux_android) \
 727      && !defined(VGPV_x86_linux_android) \
 728      && !defined(VGPV_mips32_linux_android) \
 729      && !defined(VGPV_arm64_linux_android)
 730   STRNCASECMP(VG_Z_LIBC_SONAME, strncasecmp)
 731   STRNCASECMP(VG_Z_LIBC_SONAME, __GI_strncasecmp)
 732 # endif
 733
 734 #elif defined(VGO_darwin)
 735  //STRNCASECMP(VG_Z_LIBC_SONAME, strncasecmp)
 736  //STRNCASECMP(VG_Z_DYLD,        strncasecmp)
 737
 738 #elif defined(VGO_solaris)
 739  STRNCASECMP(VG_Z_LIBC_SONAME, strncasecmp)
 740
 741 #endif
 742
 743
 744 /*---------------------- strcasecmp_l ----------------------*/
 745
 746 #define STRCASECMP_L(soname, fnname) \
 747    int VG_REPLACE_FUNCTION_EZU(20140,soname,fnname) \
 748           ( const char* s1, const char* s2, void* locale ); \
 749    int VG_REPLACE_FUNCTION_EZU(20140,soname,fnname) \
 750           ( const char* s1, const char* s2, void* locale ) \
 751    { \
 752       extern int tolower_l(int, void*) __attribute__((weak)); \
 753       register UChar c1; \
 754       register UChar c2; \
 755       while (True) { \
 756          c1 = tolower_l(*(const UChar *)s1, locale); \
 757          c2 = tolower_l(*(const UChar *)s2, locale); \
 758          if (c1 != c2) break; \
 759          if (c1 == 0) break; \
 760          s1++; s2++; \
 761       } \
 762       if ((UChar)c1 < (UChar)c2) return -1; \
 763       if ((UChar)c1 > (UChar)c2) return 1; \
 764       return 0; \
 765    }
 766
 767 #if defined(VGO_linux)
 768  STRCASECMP_L(VG_Z_LIBC_SONAME, strcasecmp_l)
 769  STRCASECMP_L(VG_Z_LIBC_SONAME, __GI_strcasecmp_l)
 770  STRCASECMP_L(VG_Z_LIBC_SONAME, __GI___strcasecmp_l)
 771
 772 #elif defined(VGO_darwin)
 773  //STRCASECMP_L(VG_Z_LIBC_SONAME, strcasecmp_l)
 774
 775 #elif defined(VGO_solaris)
 776
 777 #endif
 778
 779
 780 /*---------------------- strncasecmp_l ----------------------*/
 781
 782 #define STRNCASECMP_L(soname, fnname) \
 783    int VG_REPLACE_FUNCTION_EZU(20150,soname,fnname) \
 784           ( const char* s1, const char* s2, SizeT nmax, void* locale ); \
 785    int VG_REPLACE_FUNCTION_EZU(20150,soname,fnname) \
 786           ( const char* s1, const char* s2, SizeT nmax, void* locale ) \
 787    { \
 788       extern int tolower_l(int, void*) __attribute__((weak));    \
 789       SizeT n = 0; \
 790       while (True) { \
 791          if (n >= nmax) return 0; \
 792          if (*s1 == 0 && *s2 == 0) return 0; \
 793          if (*s1 == 0) return -1; \
 794          if (*s2 == 0) return 1; \
 795          \
 796          if (tolower_l(*(const UChar *)s1, locale) \
 797              < tolower_l(*(const UChar *)s2, locale)) return -1; \
 798          if (tolower_l(*(const UChar *)s1, locale) \
 799              > tolower_l(*(const UChar *)s2, locale)) return 1; \
 800          \
 801          s1++; s2++; n++; \
 802       } \
 803    }
 804
 805 #if defined(VGO_linux)
 806  STRNCASECMP_L(VG_Z_LIBC_SONAME, strncasecmp_l)
 807  STRNCASECMP_L(VG_Z_LIBC_SONAME, __GI_strncasecmp_l)
 808  STRNCASECMP_L(VG_Z_LIBC_SONAME, __GI___strncasecmp_l)
 809
 810 #elif defined(VGO_darwin)
 811  //STRNCASECMP_L(VG_Z_LIBC_SONAME, strncasecmp_l)
 812  //STRNCASECMP_L(VG_Z_DYLD,        strncasecmp_l)
 813
 814 #elif defined(VGO_solaris)
 815
 816 #endif
 817
 818
 819 /*---------------------- strcmp ----------------------*/
 820
 821 #define STRCMP(soname, fnname) \
 822    int VG_REPLACE_FUNCTION_EZU(20160,soname,fnname) \
 823           ( const char* s1, const char* s2 ); \
 824    int VG_REPLACE_FUNCTION_EZU(20160,soname,fnname) \
 825           ( const char* s1, const char* s2 ) \
 826    { \
 827       register UChar c1; \
 828       register UChar c2; \
 829       while (True) { \
 830          c1 = *(const UChar *)s1; \
 831          c2 = *(const UChar *)s2; \
 832          if (c1 != c2) break; \
 833          if (c1 == 0) break; \
 834          s1++; s2++; \
 835       } \
 836       if ((UChar)c1 < (UChar)c2) return -1; \
 837       if ((UChar)c1 > (UChar)c2) return 1; \
 838       return 0; \
 839    }
 840
 841 #if defined(VGO_linux)
 842  STRCMP(VG_Z_LIBC_SONAME,          strcmp)
 843  STRCMP(VG_Z_LIBC_SONAME,          __GI_strcmp)
 844  STRCMP(VG_Z_LIBC_SONAME,          __strcmp_sse2)
 845  STRCMP(VG_Z_LIBC_SONAME,          __strcmp_sse42)
 846  STRCMP(VG_Z_LD_LINUX_X86_64_SO_2, strcmp)
 847  STRCMP(VG_Z_LD64_SO_1,            strcmp)
 848 # if defined(VGPV_arm_linux_android) || defined(VGPV_x86_linux_android) \
 849      || defined(VGPV_mips32_linux_android)
 850   STRCMP(NONE, __dl_strcmp); /* in /system/bin/linker */
 851 # endif
 852
 853 #elif defined(VGO_darwin)
 854  STRCMP(VG_Z_LIBC_SONAME, strcmp)
 855 # if DARWIN_VERS >= DARWIN_10_9
 856   STRCMP(libsystemZuplatformZddylib, _platform_strcmp)
 857 # endif
 858
 859 #elif defined(VGO_solaris)
 860  STRCMP(VG_Z_LIBC_SONAME,          strcmp)
 861  STRCMP(VG_Z_LD_SO_1,              strcmp)
 862
 863 #endif
 864
 865
 866 /*---------------------- memchr ----------------------*/
 867
 868 #define MEMCHR(soname, fnname) \
 869    void* VG_REPLACE_FUNCTION_EZU(20170,soname,fnname) \
 870             (const void *s, int c, SizeT n); \
 871    void* VG_REPLACE_FUNCTION_EZU(20170,soname,fnname) \
 872             (const void *s, int c, SizeT n) \
 873    { \
 874       SizeT i; \
 875       UChar c0 = (UChar)c; \
 876       const UChar* p = s; \
 877       for (i = 0; i < n; i++) \
 878          if (p[i] == c0) return CONST_CAST(void *,&p[i]); \
 879       return NULL; \
 880    }
 881
 882 #if defined(VGO_linux)
 883  MEMCHR(VG_Z_LIBC_SONAME, memchr)
 884  MEMCHR(VG_Z_LIBC_SONAME, __GI_memchr)
 885
 886 #elif defined(VGO_darwin)
 887 # if DARWIN_VERS == DARWIN_10_9
 888   MEMCHR(VG_Z_DYLD,                   memchr)
 889   MEMCHR(libsystemZuplatformZddylib, _platform_memchr)
 890 # endif
 891 # if DARWIN_VERS >= DARWIN_10_10
 892   MEMCHR(VG_Z_DYLD,                   memchr)
 893   /* _platform_memchr$VARIANT$Generic */
 894   MEMCHR(libsystemZuplatformZddylib, _platform_memchr$VARIANT$Generic)
 895   /* _platform_memchr$VARIANT$Haswell */
 896   MEMCHR(libsystemZuplatformZddylib, _platform_memchr$VARIANT$Haswell)
 897 # endif
 898
 899 #elif defined(VGO_solaris)
 900  MEMCHR(VG_Z_LIBC_SONAME, memchr)
 901
 902 #endif
 903
 904
 905 /*---------------------- memrchr ----------------------*/
 906
 907 #define MEMRCHR(soname, fnname) \
 908    void* VG_REPLACE_FUNCTION_EZU(20360,soname,fnname) \
 909             (const void *s, int c, SizeT n); \
 910    void* VG_REPLACE_FUNCTION_EZU(20360,soname,fnname) \
 911             (const void *s, int c, SizeT n) \
 912    { \
 913       SizeT i; \
 914       UChar c0 = (UChar)c; \
 915       const UChar* p = s; \
 916       for (i = 0; i < n; i++) \
 917          if (p[n-1-i] == c0) return CONST_CAST(void *,&p[n-1-i]); \
 918       return NULL; \
 919    }
 920
 921 #if defined(VGO_linux)
 922  MEMRCHR(VG_Z_LIBC_SONAME, memrchr)
 923
 924 #elif defined(VGO_darwin)
 925  //MEMRCHR(VG_Z_LIBC_SONAME, memrchr)
 926  //MEMRCHR(VG_Z_DYLD,        memrchr)
 927
 928 #elif defined(VGO_solaris)
 929
 930 #endif
 931
 932
 933 /*---------------------- memcpy ----------------------*/
 934
 935 #define MEMMOVE_OR_MEMCPY(becTag, soname, fnname, do_ol_check)  \
 936    void* VG_REPLACE_FUNCTION_EZZ(becTag,soname,fnname) \
 937             ( void *dst, const void *src, SizeT len ); \
 938    void* VG_REPLACE_FUNCTION_EZZ(becTag,soname,fnname) \
 939             ( void *dst, const void *src, SizeT len ) \
 940    { \
 941       if (do_ol_check && is_overlap(dst, src, len, len)) \
 942          RECORD_OVERLAP_ERROR("memcpy", dst, src, len); \
 943       \
 944       const Addr WS = sizeof(UWord); /* 8 or 4 */ \
 945       const Addr WM = WS - 1;        /* 7 or 3 */ \
 946       \
 947       if (len > 0) { \
 948          if (dst < src || !is_overlap(dst, src, len, len)) { \
 949          \
 950             /* Copying backwards. */ \
 951             SizeT n = len; \
 952             Addr  d = (Addr)dst; \
 953             Addr  s = (Addr)src; \
 954             \
 955             if (((s^d) & WM) == 0) { \
 956                /* s and d have same UWord alignment. */ \
 957                /* Pull up to a UWord boundary. */ \
 958                while ((s & WM) != 0 && n >= 1) \
 959                   { *(UChar*)d = *(UChar*)s; s += 1; d += 1; n -= 1; } \
 960                /* Copy UWords. */ \
 961                while (n >= WS) \
 962                   { *(UWord*)d = *(UWord*)s; s += WS; d += WS; n -= WS; } \
 963                if (n == 0) \
 964                   return dst; \
 965             } \
 966             if (((s|d) & 1) == 0) { \
 967                /* Both are 16-aligned; copy what we can thusly. */ \
 968                while (n >= 2) \
 969                   { *(UShort*)d = *(UShort*)s; s += 2; d += 2; n -= 2; } \
 970             } \
 971             /* Copy leftovers, or everything if misaligned. */ \
 972             while (n >= 1) \
 973                { *(UChar*)d = *(UChar*)s; s += 1; d += 1; n -= 1; } \
 974          \
 975          } else if (dst > src) { \
 976          \
 977             SizeT n = len; \
 978             Addr  d = ((Addr)dst) + n; \
 979             Addr  s = ((Addr)src) + n; \
 980             \
 981             /* Copying forwards. */ \
 982             if (((s^d) & WM) == 0) { \
 983                /* s and d have same UWord alignment. */ \
 984                /* Back down to a UWord boundary. */ \
 985                while ((s & WM) != 0 && n >= 1) \
 986                   { s -= 1; d -= 1; *(UChar*)d = *(UChar*)s; n -= 1; } \
 987                /* Copy UWords. */ \
 988                while (n >= WS) \
 989                   { s -= WS; d -= WS; *(UWord*)d = *(UWord*)s; n -= WS; } \
 990                if (n == 0) \
 991                   return dst; \
 992             } \
 993             if (((s|d) & 1) == 0) { \
 994                /* Both are 16-aligned; copy what we can thusly. */ \
 995                while (n >= 2) \
 996                   { s -= 2; d -= 2; *(UShort*)d = *(UShort*)s; n -= 2; } \
 997             } \
 998             /* Copy leftovers, or everything if misaligned. */ \
 999             while (n >= 1) \
1000                { s -= 1; d -= 1; *(UChar*)d = *(UChar*)s; n -= 1; } \
1001             \
1002          } \
1003       } \
1004       \
1005       return dst; \
1006    }
1007
1008 #define MEMMOVE(soname, fnname)  \
1009    MEMMOVE_OR_MEMCPY(20181, soname, fnname, 0)
1010
1011 #define MEMCPY(soname, fnname) \
1012    MEMMOVE_OR_MEMCPY(20180, soname, fnname, 1)
1013
1014 #if defined(VGO_linux)
1015  /* For older memcpy we have to use memmove-like semantics and skip
1016     the overlap check; sigh; see #275284. */
1017  MEMMOVE(VG_Z_LIBC_SONAME, memcpyZAGLIBCZu2Zd2Zd5) /* memcpy@GLIBC_2.2.5 */
1018  MEMCPY(VG_Z_LIBC_SONAME,  memcpyZAZAGLIBCZu2Zd14) /* memcpy@@GLIBC_2.14 */
1019  MEMCPY(VG_Z_LIBC_SONAME,  memcpy) /* fallback case */
1020  MEMCPY(VG_Z_LIBC_SONAME,    __GI_memcpy)
1021  MEMCPY(VG_Z_LIBC_SONAME,    __memcpy_sse2)
1022  MEMCPY(VG_Z_LD_SO_1,      memcpy) /* ld.so.1 */
1023  MEMCPY(VG_Z_LD64_SO_1,    memcpy) /* ld64.so.1 */
1024  /* icc9 blats these around all over the place.  Not only in the main
1025     executable but various .so's.  They are highly tuned and read
1026     memory beyond the source boundary (although work correctly and
1027     never go across page boundaries), so give errors when run
1028     natively, at least for misaligned source arg.  Just intercepting
1029     in the exe only until we understand more about the problem.  See
1030     http://bugs.kde.org/show_bug.cgi?id=139776
1031  */
1032  MEMCPY(NONE, ZuintelZufastZumemcpy)
1033
1034 #elif defined(VGO_darwin)
1035 # if DARWIN_VERS <= DARWIN_10_6
1036   MEMCPY(VG_Z_LIBC_SONAME,  memcpy)
1037 # endif
1038  MEMCPY(VG_Z_LIBC_SONAME,  memcpyZDVARIANTZDsse3x) /* memcpy$VARIANT$sse3x */
1039  MEMCPY(VG_Z_LIBC_SONAME,  memcpyZDVARIANTZDsse42) /* memcpy$VARIANT$sse42 */
1040
1041 #elif defined(VGO_solaris)
1042  MEMCPY(VG_Z_LIBC_SONAME,  memcpy)
1043  MEMCPY(VG_Z_LD_SO_1,      memcpy)
1044
1045 #endif
1046
1047
1048 /*---------------------- memcmp ----------------------*/
1049
1050 #define MEMCMP(soname, fnname) \
1051    int VG_REPLACE_FUNCTION_EZU(20190,soname,fnname)       \
1052           ( const void *s1V, const void *s2V, SizeT n ); \
1053    int VG_REPLACE_FUNCTION_EZU(20190,soname,fnname)       \
1054           ( const void *s1V, const void *s2V, SizeT n )  \
1055    { \
1056       const SizeT WS = sizeof(UWord); /* 8 or 4 */ \
1057       const SizeT WM = WS - 1;        /* 7 or 3 */ \
1058       Addr s1A = (Addr)s1V; \
1059       Addr s2A = (Addr)s2V; \
1060       \
1061       if (((s1A | s2A) & WM) == 0) { \
1062          /* Both areas are word aligned.  Skip over the */ \
1063          /* equal prefix as fast as possible. */ \
1064          while (n >= WS) { \
1065             UWord w1 = *(UWord*)s1A; \
1066             UWord w2 = *(UWord*)s2A; \
1067             if (w1 != w2) break; \
1068             s1A += WS; \
1069             s2A += WS; \
1070             n -= WS; \
1071          } \
1072       } \
1073       \
1074       const UChar* s1 = (const UChar*) s1A; \
1075       const UChar* s2 = (const UChar*) s2A; \
1076       \
1077       while (n != 0) { \
1078          UChar a0 = s1[0]; \
1079          UChar b0 = s2[0]; \
1080          s1 += 1; \
1081          s2 += 1; \
1082          int res = ((int)a0) - ((int)b0); \
1083          if (res != 0) \
1084             return res; \
1085          n -= 1; \
1086       } \
1087       return 0; \
1088    }
1089
1090 #if defined(VGO_linux)
1091  MEMCMP(VG_Z_LIBC_SONAME, memcmp)
1092  MEMCMP(VG_Z_LIBC_SONAME, __GI_memcmp)
1093  MEMCMP(VG_Z_LIBC_SONAME, __memcmp_sse2)
1094  MEMCMP(VG_Z_LIBC_SONAME, __memcmp_sse4_1)
1095  MEMCMP(VG_Z_LIBC_SONAME, bcmp)
1096  MEMCMP(VG_Z_LD_SO_1,     bcmp)
1097
1098 #elif defined(VGO_darwin)
1099 # if DARWIN_VERS >= DARWIN_10_9
1100   MEMCMP(libsystemZuplatformZddylib, _platform_memcmp)
1101 # endif
1102
1103 #elif defined(VGO_solaris)
1104  MEMCMP(VG_Z_LIBC_SONAME, memcmp)
1105  MEMCMP(VG_Z_LIBC_SONAME, bcmp)
1106  MEMCMP(VG_Z_LD_SO_1,     memcmp)
1107
1108 #endif
1109
1110
1111 /*---------------------- stpcpy ----------------------*/
1112
1113 /* Copy SRC to DEST, returning the address of the terminating '\0' in
1114    DEST. (minor variant of strcpy) */
1115 #define STPCPY(soname, fnname) \
1116    char* VG_REPLACE_FUNCTION_EZU(20200,soname,fnname) \
1117             ( char* dst, const char* src ); \
1118    char* VG_REPLACE_FUNCTION_EZU(20200,soname,fnname) \
1119             ( char* dst, const char* src ) \
1120    { \
1121       const HChar* src_orig = src; \
1122             HChar* dst_orig = dst; \
1123       \
1124       while (*src) *dst++ = *src++; \
1125       *dst = 0; \
1126       \
1127       /* This checks for overlap after copying, unavoidable without */ \
1128       /* pre-counting length... should be ok */ \
1129       if (is_overlap(dst_orig,  \
1130                      src_orig,  \
1131                      (Addr)dst-(Addr)dst_orig+1,  \
1132                      (Addr)src-(Addr)src_orig+1)) \
1133          RECORD_OVERLAP_ERROR("stpcpy", dst_orig, src_orig, 0); \
1134       \
1135       return dst; \
1136    }
1137
1138 #if defined(VGO_linux)
1139  STPCPY(VG_Z_LIBC_SONAME,          stpcpy)
1140  STPCPY(VG_Z_LIBC_SONAME,          __GI_stpcpy)
1141  STPCPY(VG_Z_LIBC_SONAME,          __stpcpy_sse2)
1142  STPCPY(VG_Z_LIBC_SONAME,          __stpcpy_sse2_unaligned)
1143  STPCPY(VG_Z_LD_LINUX_SO_2,        stpcpy)
1144  STPCPY(VG_Z_LD_LINUX_X86_64_SO_2, stpcpy)
1145
1146 #elif defined(VGO_darwin)
1147  //STPCPY(VG_Z_LIBC_SONAME,          stpcpy)
1148  //STPCPY(VG_Z_DYLD,                 stpcpy)
1149
1150 #elif defined(VGO_solaris)
1151  STPCPY(VG_Z_LIBC_SONAME,          stpcpy)
1152
1153 #endif
1154
1155
1156 /*---------------------- stpncpy ----------------------*/
1157
1158 #define STPNCPY(soname, fnname) \
1159    char* VG_REPLACE_FUNCTION_EZU(20420,soname,fnname) \
1160             ( char* dst, const char* src, SizeT n ); \
1161    char* VG_REPLACE_FUNCTION_EZU(20420,soname,fnname) \
1162             ( char* dst, const char* src, SizeT n ) \
1163    { \
1164       const HChar* src_orig = src; \
1165             HChar* dst_str  = dst; \
1166       SizeT m = 0; \
1167       \
1168       while (m   < n && *src) { m++; *dst++ = *src++; } \
1169       /* Check for overlap after copying; all n bytes of dst are relevant, */ \
1170       /* but only m+1 bytes of src if terminator was found */ \
1171       if (is_overlap(dst_str, src_orig, n, (m < n) ? m+1 : n)) \
1172          RECORD_OVERLAP_ERROR("stpncpy", dst, src, n); \
1173       dst_str = dst; \
1174       while (m++ < n) *dst++ = 0;         /* must pad remainder with nulls */ \
1175       \
1176       return dst_str; \
1177    }
1178
1179 #if defined(VGO_linux)
1180  STPNCPY(VG_Z_LIBC_SONAME, stpncpy)
1181 #endif
1182
1183
1184 /*---------------------- memset ----------------------*/
1185
1186 /* Why are we bothering to intercept this?  It seems entirely
1187    pointless. */
1188
1189 #define MEMSET(soname, fnname) \
1190    void* VG_REPLACE_FUNCTION_EZU(20210,soname,fnname) \
1191             (void *s, Int c, SizeT n); \
1192    void* VG_REPLACE_FUNCTION_EZU(20210,soname,fnname) \
1193             (void *s, Int c, SizeT n) \
1194    { \
1195       if (sizeof(void*) == 8) { \
1196          Addr  a  = (Addr)s;   \
1197          ULong c8 = (c & 0xFF); \
1198          c8 = (c8 << 8) | c8; \
1199          c8 = (c8 << 16) | c8; \
1200          c8 = (c8 << 32) | c8; \
1201          while ((a & 7) != 0 && n >= 1) \
1202             { *(UChar*)a = (UChar)c; a += 1; n -= 1; } \
1203          while (n >= 8) \
1204             { *(ULong*)a = c8; a += 8; n -= 8; } \
1205          while (n >= 1) \
1206             { *(UChar*)a = (UChar)c; a += 1; n -= 1; } \
1207          return s; \
1208       } else { \
1209          Addr a  = (Addr)s;   \
1210          UInt c4 = (c & 0xFF); \
1211          c4 = (c4 << 8) | c4; \
1212          c4 = (c4 << 16) | c4; \
1213          while ((a & 3) != 0 && n >= 1) \
1214             { *(UChar*)a = (UChar)c; a += 1; n -= 1; } \
1215          while (n >= 4) \
1216             { *(UInt*)a = c4; a += 4; n -= 4; } \
1217          while (n >= 1) \
1218             { *(UChar*)a = (UChar)c; a += 1; n -= 1; } \
1219          return s; \
1220       } \
1221    }
1222
1223 #if defined(VGO_linux)
1224  MEMSET(VG_Z_LIBC_SONAME, memset)
1225
1226 #elif defined(VGO_darwin)
1227  //MEMSET(VG_Z_LIBC_SONAME, memset)
1228  //MEMSET(VG_Z_DYLD,        memset)
1229  MEMSET(VG_Z_LIBC_SONAME, memset)
1230
1231 #elif defined(VGO_solaris)
1232  MEMSET(VG_Z_LIBC_SONAME, memset)
1233
1234 #endif
1235
1236
1237 /*---------------------- memmove ----------------------*/
1238
1239 /* memmove -- use the MEMMOVE defn above. */
1240
1241 #if defined(VGO_linux)
1242  MEMMOVE(VG_Z_LIBC_SONAME, memmove)
1243  MEMMOVE(VG_Z_LIBC_SONAME, __GI_memmove)
1244  /* See bug #349828 Override for ld64.so.1 like memcpy, because for some
1245     arches MEMCPY_OK_FOR_FORWARD_MEMMOVE is set, which might cause memmove
1246     to call memcpy.  */
1247  MEMMOVE(VG_Z_LD64_SO_1, memmove)
1248
1249 #elif defined(VGO_darwin)
1250 # if DARWIN_VERS <= DARWIN_10_6
1251   MEMMOVE(VG_Z_LIBC_SONAME, memmove)
1252 # endif
1253  MEMMOVE(VG_Z_LIBC_SONAME,  memmoveZDVARIANTZDsse3x) /* memmove$VARIANT$sse3x */
1254  MEMMOVE(VG_Z_LIBC_SONAME,  memmoveZDVARIANTZDsse42) /* memmove$VARIANT$sse42 */
1255 # if DARWIN_VERS >= DARWIN_10_9
1256   /* _platform_memmove$VARIANT$Ivybridge */
1257   MEMMOVE(libsystemZuplatformZddylib, ZuplatformZumemmoveZDVARIANTZDIvybridge)
1258 # endif
1259
1260 #elif defined(VGO_solaris)
1261  MEMMOVE(VG_Z_LIBC_SONAME, memmove)
1262  MEMMOVE(VG_Z_LD_SO_1,     memmove)
1263
1264 #endif
1265
1266
1267 /*---------------------- bcopy ----------------------*/
1268
1269 #define BCOPY(soname, fnname) \
1270    void VG_REPLACE_FUNCTION_EZU(20230,soname,fnname) \
1271             (const void *srcV, void *dstV, SizeT n); \
1272    void VG_REPLACE_FUNCTION_EZU(20230,soname,fnname) \
1273             (const void *srcV, void *dstV, SizeT n) \
1274    { \
1275       SizeT i; \
1276       HChar* dst = dstV; \
1277       const HChar* src = srcV; \
1278       if (dst < src) { \
1279          for (i = 0; i < n; i++) \
1280             dst[i] = src[i]; \
1281       } \
1282       else  \
1283       if (dst > src) { \
1284          for (i = 0; i < n; i++) \
1285             dst[n-i-1] = src[n-i-1]; \
1286       } \
1287    }
1288
1289 #if defined(VGO_linux)
1290  BCOPY(VG_Z_LIBC_SONAME, bcopy)
1291
1292 #elif defined(VGO_darwin)
1293  //BCOPY(VG_Z_LIBC_SONAME, bcopy)
1294  //BCOPY(VG_Z_DYLD,        bcopy)
1295
1296 #elif defined(VGO_darwin)
1297  BCOPY(VG_Z_LIBC_SONAME, bcopy)
1298
1299 #endif
1300
1301
1302 /*-------------------- memmove_chk --------------------*/
1303
1304 /* glibc 2.5 variant of memmove which checks the dest is big enough.
1305    There is no specific part of glibc that this is copied from. */
1306 #define GLIBC25___MEMMOVE_CHK(soname, fnname) \
1307    void* VG_REPLACE_FUNCTION_EZU(20240,soname,fnname) \
1308             (void *dstV, const void *srcV, SizeT n, SizeT destlen); \
1309    void* VG_REPLACE_FUNCTION_EZU(20240,soname,fnname) \
1310             (void *dstV, const void *srcV, SizeT n, SizeT destlen) \
1311    { \
1312       SizeT i; \
1313       HChar* dst = dstV;        \
1314       const HChar* src = srcV; \
1315       if (destlen < n) \
1316          goto badness; \
1317       if (dst < src) { \
1318          for (i = 0; i < n; i++) \
1319             dst[i] = src[i]; \
1320       } \
1321       else  \
1322       if (dst > src) { \
1323          for (i = 0; i < n; i++) \
1324             dst[n-i-1] = src[n-i-1]; \
1325       } \
1326       return dst; \
1327      badness: \
1328       VALGRIND_PRINTF_BACKTRACE( \
1329          "*** memmove_chk: buffer overflow detected ***: " \
1330          "program terminated\n"); \
1331      my_exit(1); \
1332      /*NOTREACHED*/ \
1333      return NULL; \
1334    }
1335
1336 #if defined(VGO_linux)
1337  GLIBC25___MEMMOVE_CHK(VG_Z_LIBC_SONAME, __memmove_chk)
1338
1339 #elif defined(VGO_darwin)
1340
1341 #elif defined(VGO_solaris)
1342
1343 #endif
1344
1345
1346 /*-------------------- strchrnul --------------------*/
1347
1348 /* Find the first occurrence of C in S or the final NUL byte.  */
1349 #define GLIBC232_STRCHRNUL(soname, fnname) \
1350    char* VG_REPLACE_FUNCTION_EZU(20250,soname,fnname) \
1351             (const char* s, int c_in); \
1352    char* VG_REPLACE_FUNCTION_EZU(20250,soname,fnname) \
1353             (const char* s, int c_in) \
1354    { \
1355       HChar c = (HChar) c_in; \
1356       const HChar* char_ptr = s; \
1357       while (1) { \
1358          if (*char_ptr == 0) return CONST_CAST(HChar *,char_ptr);  \
1359          if (*char_ptr == c) return CONST_CAST(HChar *,char_ptr);  \
1360          char_ptr++; \
1361       } \
1362    }
1363
1364 #if defined(VGO_linux)
1365  GLIBC232_STRCHRNUL(VG_Z_LIBC_SONAME, strchrnul)
1366
1367 #elif defined(VGO_darwin)
1368
1369 #elif defined(VGO_solaris)
1370
1371 #endif
1372
1373
1374 /*---------------------- rawmemchr ----------------------*/
1375
1376 /* Find the first occurrence of C in S.  */
1377 #define GLIBC232_RAWMEMCHR(soname, fnname) \
1378    void* VG_REPLACE_FUNCTION_EZU(20260,soname,fnname) \
1379             (const void* s, int c_in); \
1380    void* VG_REPLACE_FUNCTION_EZU(20260,soname,fnname) \
1381             (const void* s, int c_in) \
1382    { \
1383       UChar c = (UChar) c_in; \
1384       const UChar* char_ptr = s; \
1385       while (1) { \
1386          if (*char_ptr == c) return CONST_CAST(void *,char_ptr); \
1387          char_ptr++; \
1388       } \
1389    }
1390
1391 #if defined (VGO_linux)
1392  GLIBC232_RAWMEMCHR(VG_Z_LIBC_SONAME, rawmemchr)
1393  GLIBC232_RAWMEMCHR(VG_Z_LIBC_SONAME, __GI___rawmemchr)
1394
1395 #elif defined(VGO_darwin)
1396
1397 #elif defined(VGO_solaris)
1398
1399 #endif
1400
1401
1402 /*---------------------- strcpy_chk ----------------------*/
1403
1404 /* glibc variant of strcpy that checks the dest is big enough.
1405    Copied from glibc-2.5/debug/test-strcpy_chk.c. */
1406 #define GLIBC25___STRCPY_CHK(soname,fnname) \
1407    char* VG_REPLACE_FUNCTION_EZU(20270,soname,fnname) \
1408             (char* dst, const char* src, SizeT len); \
1409    char* VG_REPLACE_FUNCTION_EZU(20270,soname,fnname) \
1410             (char* dst, const char* src, SizeT len) \
1411    { \
1412       HChar* ret = dst; \
1413       if (! len) \
1414          goto badness; \
1415       while ((*dst++ = *src++) != '\0') \
1416          if (--len == 0) \
1417             goto badness; \
1418       return ret; \
1419      badness: \
1420       VALGRIND_PRINTF_BACKTRACE( \
1421          "*** strcpy_chk: buffer overflow detected ***: " \
1422          "program terminated\n"); \
1423      my_exit(1); \
1424      /*NOTREACHED*/ \
1425      return NULL; \
1426    }
1427
1428 #if defined(VGO_linux)
1429  GLIBC25___STRCPY_CHK(VG_Z_LIBC_SONAME, __strcpy_chk)
1430
1431 #elif defined(VGO_darwin)
1432
1433 #elif defined(VGO_solaris)
1434
1435 #endif
1436
1437
1438 /*---------------------- stpcpy_chk ----------------------*/
1439
1440 /* glibc variant of stpcpy that checks the dest is big enough.
1441    Copied from glibc-2.5/debug/test-stpcpy_chk.c. */
1442 #define GLIBC25___STPCPY_CHK(soname,fnname) \
1443    char* VG_REPLACE_FUNCTION_EZU(20280,soname,fnname) \
1444             (char* dst, const char* src, SizeT len); \
1445    char* VG_REPLACE_FUNCTION_EZU(20280,soname,fnname) \
1446             (char* dst, const char* src, SizeT len) \
1447    { \
1448       if (! len) \
1449          goto badness; \
1450       while ((*dst++ = *src++) != '\0') \
1451          if (--len == 0) \
1452             goto badness; \
1453       return dst - 1; \
1454      badness: \
1455       VALGRIND_PRINTF_BACKTRACE( \
1456          "*** stpcpy_chk: buffer overflow detected ***: " \
1457          "program terminated\n"); \
1458      my_exit(1); \
1459      /*NOTREACHED*/ \
1460      return NULL; \
1461    }
1462
1463 #if defined(VGO_linux)
1464  GLIBC25___STPCPY_CHK(VG_Z_LIBC_SONAME, __stpcpy_chk)
1465
1466 #elif defined(VGO_darwin)
1467
1468 #elif defined(VGO_solaris)
1469
1470 #endif
1471
1472
1473 /*---------------------- mempcpy ----------------------*/
1474
1475 /* mempcpy */
1476 #define GLIBC25_MEMPCPY(soname, fnname) \
1477    void* VG_REPLACE_FUNCTION_EZU(20290,soname,fnname) \
1478             ( void *dst, const void *src, SizeT len ); \
1479    void* VG_REPLACE_FUNCTION_EZU(20290,soname,fnname) \
1480             ( void *dst, const void *src, SizeT len ) \
1481    { \
1482       SizeT len_saved = len; \
1483       \
1484       if (len == 0) \
1485          return dst; \
1486       \
1487       if (is_overlap(dst, src, len, len)) \
1488          RECORD_OVERLAP_ERROR("mempcpy", dst, src, len); \
1489       \
1490       if ( dst > src ) { \
1491          register HChar *d = (char *)dst + len - 1; \
1492          register const HChar *s = (const char *)src + len - 1; \
1493          while ( len-- ) { \
1494             *d-- = *s--; \
1495          } \
1496       } else if ( dst < src ) { \
1497          register HChar *d = dst; \
1498          register const HChar *s = src; \
1499          while ( len-- ) { \
1500             *d++ = *s++; \
1501          } \
1502       } \
1503       return (void*)( ((char*)dst) + len_saved ); \
1504    }
1505
1506 #if defined(VGO_linux)
1507  GLIBC25_MEMPCPY(VG_Z_LIBC_SONAME, mempcpy)
1508  GLIBC25_MEMPCPY(VG_Z_LIBC_SONAME, __GI_mempcpy)
1509  GLIBC25_MEMPCPY(VG_Z_LD_SO_1,     mempcpy) /* ld.so.1 */
1510  GLIBC25_MEMPCPY(VG_Z_LD_LINUX_SO_3, mempcpy) /* ld-linux.so.3 */
1511  GLIBC25_MEMPCPY(VG_Z_LD_LINUX_X86_64_SO_2, mempcpy) /* ld-linux-x86-64.so.2 */
1512
1513 #elif defined(VGO_darwin)
1514  //GLIBC25_MEMPCPY(VG_Z_LIBC_SONAME, mempcpy)
1515
1516 #elif defined(VGO_solaris)
1517
1518 #endif
1519
1520
1521 /*-------------------- memcpy_chk --------------------*/
1522
1523 #define GLIBC26___MEMCPY_CHK(soname, fnname) \
1524    void* VG_REPLACE_FUNCTION_EZU(20300,soname,fnname) \
1525             (void* dst, const void* src, SizeT len, SizeT dstlen ); \
1526    void* VG_REPLACE_FUNCTION_EZU(20300,soname,fnname) \
1527             (void* dst, const void* src, SizeT len, SizeT dstlen ) \
1528    { \
1529       register HChar *d; \
1530       register const HChar *s; \
1531       \
1532       if (dstlen < len) goto badness; \
1533       \
1534       if (len == 0) \
1535          return dst; \
1536       \
1537       if (is_overlap(dst, src, len, len)) \
1538          RECORD_OVERLAP_ERROR("memcpy_chk", dst, src, len); \
1539       \
1540       if ( dst > src ) { \
1541          d = (HChar *)dst + len - 1; \
1542          s = (const HChar *)src + len - 1; \
1543          while ( len-- ) { \
1544             *d-- = *s--; \
1545          } \
1546       } else if ( dst < src ) { \
1547          d = (HChar *)dst; \
1548          s = (const HChar *)src; \
1549          while ( len-- ) { \
1550             *d++ = *s++; \
1551          } \
1552       } \
1553       return dst; \
1554      badness: \
1555       VALGRIND_PRINTF_BACKTRACE( \
1556          "*** memcpy_chk: buffer overflow detected ***: " \
1557          "program terminated\n"); \
1558      my_exit(1); \
1559      /*NOTREACHED*/ \
1560      return NULL; \
1561    }
1562
1563 #if defined(VGO_linux)
1564  GLIBC26___MEMCPY_CHK(VG_Z_LIBC_SONAME, __memcpy_chk)
1565
1566 #elif defined(VGO_darwin)
1567
1568 #elif defined(VGO_solaris)
1569
1570 #endif
1571
1572
1573 /*---------------------- strstr ----------------------*/
1574
1575 #define STRSTR(soname, fnname) \
1576    char* VG_REPLACE_FUNCTION_EZU(20310,soname,fnname) \
1577          (const char* haystack, const char* needle); \
1578    char* VG_REPLACE_FUNCTION_EZU(20310,soname,fnname) \
1579          (const char* haystack, const char* needle) \
1580    { \
1581       const HChar* h = haystack; \
1582       const HChar* n = needle; \
1583       \
1584       /* find the length of n, not including terminating zero */ \
1585       UWord nlen = 0; \
1586       while (n[nlen]) nlen++; \
1587       \
1588       /* if n is the empty string, match immediately. */ \
1589       if (nlen == 0) return CONST_CAST(HChar *,h);         \
1590       \
1591       /* assert(nlen >= 1); */ \
1592       HChar n0 = n[0]; \
1593       \
1594       while (1) { \
1595          const HChar hh = *h; \
1596          if (hh == 0) return NULL; \
1597          if (hh != n0) { h++; continue; } \
1598          \
1599          UWord i; \
1600          for (i = 0; i < nlen; i++) { \
1601             if (n[i] != h[i]) \
1602                break; \
1603          } \
1604          /* assert(i >= 0 && i <= nlen); */ \
1605          if (i == nlen) \
1606            return CONST_CAST(HChar *,h);          \
1607          \
1608          h++; \
1609       } \
1610    }
1611
1612 #if defined(VGO_linux)
1613  STRSTR(VG_Z_LIBC_SONAME,          strstr)
1614  STRSTR(VG_Z_LIBC_SONAME,          __strstr_sse2)
1615  STRSTR(VG_Z_LIBC_SONAME,          __strstr_sse42)
1616
1617 #elif defined(VGO_darwin)
1618
1619 #elif defined(VGO_solaris)
1620  STRSTR(VG_Z_LIBC_SONAME,          strstr)
1621
1622 #endif
1623
1624
1625 /*---------------------- strpbrk ----------------------*/
1626
1627 #define STRPBRK(soname, fnname) \
1628    char* VG_REPLACE_FUNCTION_EZU(20320,soname,fnname) \
1629          (const char* sV, const char* acceptV); \
1630    char* VG_REPLACE_FUNCTION_EZU(20320,soname,fnname) \
1631          (const char* sV, const char* acceptV) \
1632    { \
1633       const HChar* s = sV; \
1634       const HChar* accept = acceptV; \
1635       \
1636       /*  find the length of 'accept', not including terminating zero */ \
1637       UWord nacc = 0; \
1638       while (accept[nacc]) nacc++; \
1639       \
1640       /* if n is the empty string, fail immediately. */ \
1641       if (nacc == 0) return NULL; \
1642       \
1643       /* assert(nacc >= 1); */ \
1644       while (1) { \
1645          UWord i; \
1646          HChar sc = *s; \
1647          if (sc == 0) \
1648             break; \
1649          for (i = 0; i < nacc; i++) { \
1650             if (sc == accept[i]) \
1651               return CONST_CAST(HChar *,s);       \
1652          } \
1653          s++; \
1654       } \
1655       \
1656       return NULL; \
1657    }
1658
1659 #if defined(VGO_linux)
1660  STRPBRK(VG_Z_LIBC_SONAME,          strpbrk)
1661
1662 #elif defined(VGO_darwin)
1663
1664 #elif defined(VGO_solaris)
1665  STRPBRK(VG_Z_LIBC_SONAME,          strpbrk)
1666
1667 #endif
1668
1669
1670 /*---------------------- strcspn ----------------------*/
1671
1672 #define STRCSPN(soname, fnname) \
1673    SizeT VG_REPLACE_FUNCTION_EZU(20330,soname,fnname) \
1674          (const char* sV, const char* rejectV); \
1675    SizeT VG_REPLACE_FUNCTION_EZU(20330,soname,fnname) \
1676          (const char* sV, const char* rejectV) \
1677    { \
1678       const HChar* s = sV; \
1679       const HChar* reject = rejectV; \
1680       \
1681       /* find the length of 'reject', not including terminating zero */ \
1682       UWord nrej = 0; \
1683       while (reject[nrej]) nrej++; \
1684       \
1685       UWord len = 0; \
1686       while (1) { \
1687          UWord i; \
1688          HChar sc = *s; \
1689          if (sc == 0) \
1690             break; \
1691          for (i = 0; i < nrej; i++) { \
1692             if (sc == reject[i]) \
1693                break; \
1694          } \
1695          /* assert(i >= 0 && i <= nrej); */ \
1696          if (i < nrej) \
1697             break; \
1698          s++; \
1699          len++; \
1700       } \
1701       \
1702       return len; \
1703    }
1704
1705 #if defined(VGO_linux)
1706  STRCSPN(VG_Z_LIBC_SONAME,          strcspn)
1707
1708 #elif defined(VGO_darwin)
1709
1710 #elif defined(VGO_solaris)
1711  STRCSPN(VG_Z_LIBC_SONAME,          strcspn)
1712
1713 #endif
1714
1715
1716 /*---------------------- strspn ----------------------*/
1717
1718 #define STRSPN(soname, fnname) \
1719    SizeT VG_REPLACE_FUNCTION_EZU(20340,soname,fnname) \
1720          (const char* sV, const char* acceptV); \
1721    SizeT VG_REPLACE_FUNCTION_EZU(20340,soname,fnname) \
1722          (const char* sV, const char* acceptV) \
1723    { \
1724       const UChar* s = (const UChar *)sV;        \
1725       const UChar* accept = (const UChar *)acceptV;     \
1726       \
1727       /* find the length of 'accept', not including terminating zero */ \
1728       UWord nacc = 0; \
1729       while (accept[nacc]) nacc++; \
1730       if (nacc == 0) return 0; \
1731       \
1732       UWord len = 0; \
1733       while (1) { \
1734          UWord i; \
1735          HChar sc = *s; \
1736          if (sc == 0) \
1737             break; \
1738          for (i = 0; i < nacc; i++) { \
1739             if (sc == accept[i]) \
1740                break; \
1741          } \
1742          /* assert(i >= 0 && i <= nacc); */ \
1743          if (i == nacc) \
1744             break; \
1745          s++; \
1746          len++; \
1747       } \
1748       \
1749       return len; \
1750    }
1751
1752 #if defined(VGO_linux)
1753  STRSPN(VG_Z_LIBC_SONAME,          strspn)
1754
1755 #elif defined(VGO_darwin)
1756
1757 #elif defined(VGO_solaris)
1758  STRSPN(VG_Z_LIBC_SONAME,          strspn)
1759
1760 #endif
1761
1762
1763 /*---------------------- strcasestr ----------------------*/
1764
1765 #define STRCASESTR(soname, fnname) \
1766    char* VG_REPLACE_FUNCTION_EZU(20350,soname,fnname) \
1767          (const char* haystack, const char* needle); \
1768    char* VG_REPLACE_FUNCTION_EZU(20350,soname,fnname) \
1769          (const char* haystack, const char* needle) \
1770    { \
1771       extern int tolower(int); \
1772       const HChar* h = haystack; \
1773       const HChar* n = needle;   \
1774       \
1775       /* find the length of n, not including terminating zero */ \
1776       UWord nlen = 0; \
1777       while (n[nlen]) nlen++; \
1778       \
1779       /* if n is the empty string, match immediately. */ \
1780       if (nlen == 0) return CONST_CAST(HChar *,h);       \
1781       \
1782       /* assert(nlen >= 1); */ \
1783       UChar n0 = tolower(n[0]);                 \
1784       \
1785       while (1) { \
1786          UChar hh = tolower(*h);    \
1787          if (hh == 0) return NULL; \
1788          if (hh != n0) { h++; continue; } \
1789          \
1790          UWord i; \
1791          for (i = 0; i < nlen; i++) { \
1792             if (tolower(n[i]) != tolower(h[i]))  \
1793                break; \
1794          } \
1795          /* assert(i >= 0 && i <= nlen); */ \
1796          if (i == nlen) \
1797            return CONST_CAST(HChar *,h);    \
1798          \
1799          h++; \
1800       } \
1801    }
1802
1803 #if defined(VGO_linux)
1804 # if !defined(VGPV_arm_linux_android) \
1805      && !defined(VGPV_x86_linux_android) \
1806      && !defined(VGPV_mips32_linux_android) \
1807      && !defined(VGPV_arm64_linux_android)
1808   STRCASESTR(VG_Z_LIBC_SONAME,      strcasestr)
1809 # endif
1810
1811 #elif defined(VGO_darwin)
1812
1813 #elif defined(VGO_solaris)
1814   STRCASESTR(VG_Z_LIBC_SONAME,      strcasestr)
1815
1816 #endif
1817
1818
1819 /*---------------------- wcslen ----------------------*/
1820
1821 // This is a wchar_t equivalent to strlen.  Unfortunately
1822 // we don't have wchar_t available here, but it looks like
1823 // a 32 bit int on Linux.  I don't know if that is also
1824 // valid on MacOSX.
1825
1826 #define WCSLEN(soname, fnname) \
1827    SizeT VG_REPLACE_FUNCTION_EZU(20370,soname,fnname) \
1828       ( const UInt* str ); \
1829    SizeT VG_REPLACE_FUNCTION_EZU(20370,soname,fnname) \
1830       ( const UInt* str )  \
1831    { \
1832       SizeT i = 0; \
1833       while (str[i] != 0) i++; \
1834       return i; \
1835    }
1836
1837 #if defined(VGO_linux)
1838  WCSLEN(VG_Z_LIBC_SONAME,          wcslen)
1839
1840 #elif defined(VGO_darwin)
1841
1842 #elif defined(VGO_solaris)
1843  WCSLEN(VG_Z_LIBC_SONAME,          wcslen)
1844
1845 #endif
1846
1847 /*---------------------- wcscmp ----------------------*/
1848
1849 // This is a wchar_t equivalent to strcmp.  We don't
1850 // have wchar_t available here, but in the GNU C Library
1851 // wchar_t is always 32 bits wide and wcscmp uses signed
1852 // comparison, not unsigned as in strcmp function.
1853
1854 #define WCSCMP(soname, fnname) \
1855    int VG_REPLACE_FUNCTION_EZU(20380,soname,fnname) \
1856           ( const Int* s1, const Int* s2 ); \
1857    int VG_REPLACE_FUNCTION_EZU(20380,soname,fnname) \
1858           ( const Int* s1, const Int* s2 ) \
1859    { \
1860       register Int c1; \
1861       register Int c2; \
1862       while (True) { \
1863          c1 = *s1; \
1864          c2 = *s2; \
1865          if (c1 != c2) break; \
1866          if (c1 == 0) break; \
1867          s1++; s2++; \
1868       } \
1869       if (c1 < c2) return -1; \
1870       if (c1 > c2) return 1; \
1871       return 0; \
1872    }
1873
1874 #if defined(VGO_linux)
1875  WCSCMP(VG_Z_LIBC_SONAME,          wcscmp)
1876 #endif
1877
1878 /*---------------------- wcscpy ----------------------*/
1879
1880 // This is a wchar_t equivalent to strcpy.  We don't
1881 // have wchar_t available here, but in the GNU C Library
1882 // wchar_t is always 32 bits wide.
1883
1884 #define WCSCPY(soname, fnname) \
1885    Int* VG_REPLACE_FUNCTION_EZU(20390,soname,fnname) \
1886       ( Int* dst, const Int* src ); \
1887    Int* VG_REPLACE_FUNCTION_EZU(20390,soname,fnname) \
1888       ( Int* dst, const Int* src ) \
1889    { \
1890       const Int* src_orig = src; \
1891             Int* dst_orig = dst; \
1892       \
1893       while (*src) *dst++ = *src++; \
1894       *dst = 0; \
1895       \
1896       /* This checks for overlap after copying, unavoidable without */ \
1897       /* pre-counting length... should be ok */ \
1898       if (is_overlap(dst_orig,  \
1899                      src_orig,  \
1900                      (Addr)dst-(Addr)dst_orig+1, \
1901                      (Addr)src-(Addr)src_orig+1)) \
1902          RECORD_OVERLAP_ERROR("wcscpy", dst_orig, src_orig, 0); \
1903       \
1904       return dst_orig; \
1905    }
1906
1907 #if defined(VGO_linux)
1908  WCSCPY(VG_Z_LIBC_SONAME, wcscpy)
1909 #endif
1910
1911
1912 /*---------------------- wcschr ----------------------*/
1913
1914 // This is a wchar_t equivalent to strchr.  We don't
1915 // have wchar_t available here, but in the GNU C Library
1916 // wchar_t is always 32 bits wide.
1917
1918 #define WCSCHR(soname, fnname) \
1919    Int* VG_REPLACE_FUNCTION_EZU(20400,soname,fnname) ( const Int* s, Int c ); \
1920    Int* VG_REPLACE_FUNCTION_EZU(20400,soname,fnname) ( const Int* s, Int c ) \
1921    { \
1922       const Int* p = s; \
1923       while (True) { \
1924          if (*p == c) return CONST_CAST(Int *,p);  \
1925          if (*p == 0) return NULL; \
1926          p++; \
1927       } \
1928    }
1929
1930 #if defined(VGO_linux)
1931  WCSCHR(VG_Z_LIBC_SONAME,          wcschr)
1932 #endif
1933 /*---------------------- wcsrchr ----------------------*/
1934
1935 // This is a wchar_t equivalent to strrchr.  We don't
1936 // have wchar_t available here, but in the GNU C Library
1937 // wchar_t is always 32 bits wide.
1938
1939 #define WCSRCHR(soname, fnname) \
1940    Int* VG_REPLACE_FUNCTION_EZU(20410,soname,fnname)( const Int* s, Int c ); \
1941    Int* VG_REPLACE_FUNCTION_EZU(20410,soname,fnname)( const Int* s, Int c ) \
1942    { \
1943       const Int* p = s; \
1944       const Int* last = NULL; \
1945       while (True) { \
1946          if (*p == c) last = p; \
1947          if (*p == 0) return CONST_CAST(Int *,last);  \
1948          p++; \
1949       } \
1950    }
1951
1952 #if defined(VGO_linux)
1953  WCSRCHR(VG_Z_LIBC_SONAME, wcsrchr)
1954 #endif
1955
1956 /*------------------------------------------------------------*/
1957 /*--- Improve definedness checking of process environment  ---*/
1958 /*------------------------------------------------------------*/
1959
1960 #if defined(VGO_linux)
1961
1962 /* If these wind up getting generated via a macro, so that multiple
1963    versions of each function exist (as above), use the _EZU variants
1964    to assign equivalance class tags. */
1965
1966 /*---------------------- putenv ----------------------*/
1967
1968 int VG_WRAP_FUNCTION_ZU(VG_Z_LIBC_SONAME, putenv) (char* string);
1969 int VG_WRAP_FUNCTION_ZU(VG_Z_LIBC_SONAME, putenv) (char* string)
1970 {
1971     OrigFn fn;
1972     Word result;
1973     const HChar* p = string;
1974     VALGRIND_GET_ORIG_FN(fn);
1975     /* Now by walking over the string we magically produce
1976        traces when hitting undefined memory. */
1977     if (p)
1978         while (*p++)
1979             __asm__ __volatile__("" ::: "memory");
1980     CALL_FN_W_W(result, fn, string);
1981     return result;
1982 }
1983
1984
1985 /*---------------------- unsetenv ----------------------*/
1986
1987 int VG_WRAP_FUNCTION_ZU(VG_Z_LIBC_SONAME, unsetenv) (const char* name);
1988 int VG_WRAP_FUNCTION_ZU(VG_Z_LIBC_SONAME, unsetenv) (const char* name)
1989 {
1990     OrigFn fn;
1991     Word result;
1992     const HChar* p = name;
1993     VALGRIND_GET_ORIG_FN(fn);
1994     /* Now by walking over the string we magically produce
1995        traces when hitting undefined memory. */
1996     if (p)
1997         while (*p++)
1998             __asm__ __volatile__("" ::: "memory");
1999     CALL_FN_W_W(result, fn, name);
2000     return result;
2001 }
2002
2003
2004 /*---------------------- setenv ----------------------*/
2005
2006 /* setenv */
2007 int VG_WRAP_FUNCTION_ZU(VG_Z_LIBC_SONAME, setenv)
2008     (const char* name, const char* value, int overwrite);
2009 int VG_WRAP_FUNCTION_ZU(VG_Z_LIBC_SONAME, setenv)
2010     (const char* name, const char* value, int overwrite)
2011 {
2012     OrigFn fn;
2013     Word result;
2014     const HChar* p;
2015     VALGRIND_GET_ORIG_FN(fn);
2016     /* Now by walking over the string we magically produce
2017        traces when hitting undefined memory. */
2018     if (name)
2019         for (p = name; *p; p++)
2020             __asm__ __volatile__("" ::: "memory");
2021     if (value)
2022         for (p = value; *p; p++)
2023             __asm__ __volatile__("" ::: "memory");
2024     (void) VALGRIND_CHECK_VALUE_IS_DEFINED (overwrite);
2025     CALL_FN_W_WWW(result, fn, name, value, overwrite);
2026     return result;
2027 }
2028
2029 #endif /* defined(VGO_linux) */
2030
2031 /*--------------------------------------------------------------------*/
2032 /*--- end                                                          ---*/
2033 /*--------------------------------------------------------------------*/