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