1 2 /*--------------------------------------------------------------------*/ 3 /*--- Ptrcheck: a pointer-use checker. pc_intercepts.c ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Ptrcheck, a Valgrind tool for checking pointer 8 use in programs. 9 10 Copyright (C) 2003-2017 Nicholas Nethercote 11 njn@valgrind.org 12 13 This program is free software; you can redistribute it and/or 14 modify it under the terms of the GNU General Public License as 15 published by the Free Software Foundation; either version 2 of the 16 License, or (at your option) any later version. 17 18 This program is distributed in the hope that it will be useful, but 19 WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 General Public License for more details. 22 23 You should have received a copy of the GNU General Public License 24 along with this program; if not, write to the Free Software 25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 26 02111-1307, USA. 27 28 The GNU General Public License is contained in the file COPYING. 29 */ 30 31 /* Nothing actually in here. However it appears this file is needed 32 to make malloc intercepting work. (jrs, 2 july 08 -- not sure about 33 that). 34 */ 35 36 #include "pub_tool_basics.h" 37 #include "pub_tool_hashtable.h" 38 #include "pub_tool_redir.h" 39 #include "pub_tool_tooliface.h" 40 #include "pub_tool_clreq.h" 41 42 43 /* The following intercepts are copied verbatim from 44 memcheck/mc_replace_strmem.c. If you copy more in, please keep 45 them in the same order as in mc_replace_strmem.c. */ 46 47 48 #define STRRCHR(soname, fnname) \ 49 char* VG_REPLACE_FUNCTION_ZU(soname,fnname)( const char* s, int c ); \ 50 char* VG_REPLACE_FUNCTION_ZU(soname,fnname)( const char* s, int c ) \ 51 { \ 52 HChar ch = (HChar)c; \ 53 const HChar* p = s; \ 54 const HChar* last = NULL; \ 55 while (True) { \ 56 if (*p == ch) last = p; \ 57 if (*p == 0) return CONST_CAST(HChar *,last); \ 58 p++; \ 59 } \ 60 } 61 62 // Apparently rindex() is the same thing as strrchr() 63 STRRCHR(VG_Z_LIBC_SONAME, strrchr) 64 STRRCHR(VG_Z_LIBC_SONAME, rindex) 65 #if defined(VGO_linux) 66 STRRCHR(VG_Z_LIBC_SONAME, __GI_strrchr) 67 STRRCHR(VG_Z_LD_LINUX_SO_2, rindex) 68 #elif defined(VGO_darwin) 69 STRRCHR(VG_Z_DYLD, strrchr) 70 STRRCHR(VG_Z_DYLD, rindex) 71 #elif defined(VGO_solaris) 72 STRRCHR(VG_Z_LD_SO_1, strrchr) 73 #endif 74 75 76 #define STRCHR(soname, fnname) \ 77 char* VG_REPLACE_FUNCTION_ZU(soname,fnname) ( const char* s, int c ); \ 78 char* VG_REPLACE_FUNCTION_ZU(soname,fnname) ( const char* s, int c ) \ 79 { \ 80 HChar ch = (HChar)c ; \ 81 const HChar* p = s; \ 82 while (True) { \ 83 if (*p == ch) return CONST_CAST(HChar *,p); \ 84 if (*p == 0) return NULL; \ 85 p++; \ 86 } \ 87 } 88 89 // Apparently index() is the same thing as strchr() 90 STRCHR(VG_Z_LIBC_SONAME, strchr) 91 STRCHR(VG_Z_LIBC_SONAME, index) 92 #if defined(VGO_linux) 93 STRCHR(VG_Z_LIBC_SONAME, __GI_strchr) 94 STRCHR(VG_Z_LD_LINUX_SO_2, strchr) 95 STRCHR(VG_Z_LD_LINUX_SO_2, index) 96 STRCHR(VG_Z_LD_LINUX_X86_64_SO_2, strchr) 97 STRCHR(VG_Z_LD_LINUX_X86_64_SO_2, index) 98 #elif defined(VGO_darwin) 99 STRCHR(VG_Z_DYLD, strchr) 100 STRCHR(VG_Z_DYLD, index) 101 #elif defined(VGO_solaris) 102 STRCHR(VG_Z_LD_SO_1, strchr) 103 #endif 104 105 106 #define STRNLEN(soname, fnname) \ 107 SizeT VG_REPLACE_FUNCTION_ZU(soname,fnname) ( const char* str, SizeT n ); \ 108 SizeT VG_REPLACE_FUNCTION_ZU(soname,fnname) ( const char* str, SizeT n ) \ 109 { \ 110 SizeT i = 0; \ 111 while (i < n && str[i] != 0) i++; \ 112 return i; \ 113 } 114 115 STRNLEN(VG_Z_LIBC_SONAME, strnlen) 116 117 118 // Note that this replacement often doesn't get used because gcc inlines 119 // calls to strlen() with its own built-in version. This can be very 120 // confusing if you aren't expecting it. Other small functions in this file 121 // may also be inline by gcc. 122 #define STRLEN(soname, fnname) \ 123 SizeT VG_REPLACE_FUNCTION_ZU(soname,fnname)( const char* str ); \ 124 SizeT VG_REPLACE_FUNCTION_ZU(soname,fnname)( const char* str ) \ 125 { \ 126 SizeT i = 0; \ 127 while (str[i] != 0) i++; \ 128 return i; \ 129 } 130 131 STRLEN(VG_Z_LIBC_SONAME, strlen) 132 #if defined(VGO_linux) 133 STRLEN(VG_Z_LIBC_SONAME, __GI_strlen) 134 STRLEN(VG_Z_LD_LINUX_SO_2, strlen) 135 STRLEN(VG_Z_LD_LINUX_X86_64_SO_2, strlen) 136 STRLEN(VG_Z_LD_SO_1, strlen) 137 #elif defined(VGO_solaris) 138 STRLEN(VG_Z_LD_SO_1, strlen) 139 #endif 140 141 142 #define STRCPY(soname, fnname) \ 143 char* VG_REPLACE_FUNCTION_ZU(soname, fnname) ( char* dst, const char* src ); \ 144 char* VG_REPLACE_FUNCTION_ZU(soname, fnname) ( char* dst, const char* src ) \ 145 { \ 146 HChar* dst_orig = dst; \ 147 \ 148 while (*src) *dst++ = *src++; \ 149 *dst = 0; \ 150 \ 151 return dst_orig; \ 152 } 153 154 STRCPY(VG_Z_LIBC_SONAME, strcpy) 155 #if defined(VGO_linux) 156 STRCPY(VG_Z_LIBC_SONAME, __GI_strcpy) 157 #elif defined(VGO_darwin) 158 STRCPY(VG_Z_DYLD, strcpy) 159 #elif defined(VGO_solaris) 160 STRCPY(VG_Z_LD_SO_1, strcpy) 161 #endif 162 163 164 #define STRNCMP(soname, fnname) \ 165 int VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 166 ( const char* s1, const char* s2, SizeT nmax ); \ 167 int VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 168 ( const char* s1, const char* s2, SizeT nmax ) \ 169 { \ 170 SizeT n = 0; \ 171 while (True) { \ 172 if (n >= nmax) return 0; \ 173 if (*s1 == 0 && *s2 == 0) return 0; \ 174 if (*s1 == 0) return -1; \ 175 if (*s2 == 0) return 1; \ 176 \ 177 if (*(const unsigned char*)s1 < *(const unsigned char*)s2) return -1; \ 178 if (*(const unsigned char*)s1 > *(const unsigned char*)s2) return 1; \ 179 \ 180 s1++; s2++; n++; \ 181 } \ 182 } 183 184 STRNCMP(VG_Z_LIBC_SONAME, strncmp) 185 #if defined(VGO_linux) 186 STRNCMP(VG_Z_LIBC_SONAME, __GI_strncmp) 187 #elif defined(VGO_darwin) 188 STRNCMP(VG_Z_DYLD, strncmp) 189 #endif 190 191 192 #define STRCMP(soname, fnname) \ 193 int VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 194 ( const char* s1, const char* s2 ); \ 195 int VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 196 ( const char* s1, const char* s2 ) \ 197 { \ 198 register UChar c1; \ 199 register UChar c2; \ 200 while (True) { \ 201 c1 = *(const UChar *)s1; \ 202 c2 = *(const UChar *)s2; \ 203 if (c1 != c2) break; \ 204 if (c1 == 0) break; \ 205 s1++; s2++; \ 206 } \ 207 if ((UChar)c1 < (UChar)c2) return -1; \ 208 if ((UChar)c1 > (UChar)c2) return 1; \ 209 return 0; \ 210 } 211 212 STRCMP(VG_Z_LIBC_SONAME, strcmp) 213 #if defined(VGO_linux) 214 STRCMP(VG_Z_LIBC_SONAME, __GI_strcmp) 215 STRCMP(VG_Z_LD_LINUX_X86_64_SO_2, strcmp) 216 STRCMP(VG_Z_LD64_SO_1, strcmp) 217 #elif defined(VGO_solaris) 218 STRCMP(VG_Z_LD_SO_1, strcmp) 219 #endif 220 221 222 #define MEMCHR(soname, fnname) \ 223 void* VG_REPLACE_FUNCTION_ZU(soname,fnname) (const void *s, int c, SizeT n); \ 224 void* VG_REPLACE_FUNCTION_ZU(soname,fnname) (const void *s, int c, SizeT n) \ 225 { \ 226 SizeT i; \ 227 UChar c0 = (UChar)c; \ 228 const UChar* p = s; \ 229 for (i = 0; i < n; i++) \ 230 if (p[i] == c0) return CONST_CAST(void *,&p[i]); \ 231 return NULL; \ 232 } 233 234 MEMCHR(VG_Z_LIBC_SONAME, memchr) 235 #if defined(VGO_darwin) 236 MEMCHR(VG_Z_DYLD, memchr) 237 #endif 238 239 240 #define MEMCPY(soname, fnname) \ 241 void* VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 242 ( void *dst, const void *src, SizeT len ); \ 243 void* VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 244 ( void *dst, const void *src, SizeT len ) \ 245 { \ 246 const Addr WS = sizeof(UWord); /* 8 or 4 */ \ 247 const Addr WM = WS - 1; /* 7 or 3 */ \ 248 \ 249 if (len > 0) { \ 250 if (dst < src) { \ 251 \ 252 /* Copying backwards. */ \ 253 SizeT n = len; \ 254 Addr d = (Addr)dst; \ 255 Addr s = (Addr)src; \ 256 \ 257 if (((s^d) & WM) == 0) { \ 258 /* s and d have same UWord alignment. */ \ 259 /* Pull up to a UWord boundary. */ \ 260 while ((s & WM) != 0 && n >= 1) \ 261 { *(UChar*)d = *(UChar*)s; s += 1; d += 1; n -= 1; } \ 262 /* Copy UWords. */ \ 263 while (n >= WS) \ 264 { *(UWord*)d = *(UWord*)s; s += WS; d += WS; n -= WS; } \ 265 if (n == 0) \ 266 return dst; \ 267 } \ 268 if (((s|d) & 1) == 0) { \ 269 /* Both are 16-aligned; copy what we can thusly. */ \ 270 while (n >= 2) \ 271 { *(UShort*)d = *(UShort*)s; s += 2; d += 2; n -= 2; } \ 272 } \ 273 /* Copy leftovers, or everything if misaligned. */ \ 274 while (n >= 1) \ 275 { *(UChar*)d = *(UChar*)s; s += 1; d += 1; n -= 1; } \ 276 \ 277 } else if (dst > src) { \ 278 \ 279 SizeT n = len; \ 280 Addr d = ((Addr)dst) + n; \ 281 Addr s = ((Addr)src) + n; \ 282 \ 283 /* Copying forwards. */ \ 284 if (((s^d) & WM) == 0) { \ 285 /* s and d have same UWord alignment. */ \ 286 /* Back down to a UWord boundary. */ \ 287 while ((s & WM) != 0 && n >= 1) \ 288 { s -= 1; d -= 1; *(UChar*)d = *(UChar*)s; n -= 1; } \ 289 /* Copy UWords. */ \ 290 while (n >= WS) \ 291 { s -= WS; d -= WS; *(UWord*)d = *(UWord*)s; n -= WS; } \ 292 if (n == 0) \ 293 return dst; \ 294 } \ 295 if (((s|d) & 1) == 0) { \ 296 /* Both are 16-aligned; copy what we can thusly. */ \ 297 while (n >= 2) \ 298 { s -= 2; d -= 2; *(UShort*)d = *(UShort*)s; n -= 2; } \ 299 } \ 300 /* Copy leftovers, or everything if misaligned. */ \ 301 while (n >= 1) \ 302 { s -= 1; d -= 1; *(UChar*)d = *(UChar*)s; n -= 1; } \ 303 \ 304 } \ 305 } \ 306 \ 307 return dst; \ 308 } 309 310 MEMCPY(VG_Z_LIBC_SONAME, memcpy) 311 #if defined(VGO_linux) 312 MEMCPY(VG_Z_LD_SO_1, memcpy) /* ld.so.1 */ 313 MEMCPY(VG_Z_LD64_SO_1, memcpy) /* ld64.so.1 */ 314 #elif defined(VGO_solaris) 315 MEMCPY(VG_Z_LD_SO_1, memcpy) 316 #endif 317 318 319 /* Copy SRC to DEST, returning the address of the terminating '\0' in 320 DEST. (minor variant of strcpy) */ 321 #define STPCPY(soname, fnname) \ 322 char* VG_REPLACE_FUNCTION_ZU(soname,fnname) ( char* dst, const char* src ); \ 323 char* VG_REPLACE_FUNCTION_ZU(soname,fnname) ( char* dst, const char* src ) \ 324 { \ 325 while (*src) *dst++ = *src++; \ 326 *dst = 0; \ 327 \ 328 return dst; \ 329 } 330 331 STPCPY(VG_Z_LIBC_SONAME, stpcpy) 332 #if defined(VGO_linux) 333 STPCPY(VG_Z_LD_LINUX_SO_2, stpcpy) 334 STPCPY(VG_Z_LD_LINUX_X86_64_SO_2, stpcpy) 335 #endif 336 337 338 /* Find the first occurrence of C in S. */ 339 #define GLIBC232_RAWMEMCHR(soname, fnname) \ 340 void* VG_REPLACE_FUNCTION_ZU(soname,fnname) (const void* s, int c_in); \ 341 void* VG_REPLACE_FUNCTION_ZU(soname,fnname) (const void* s, int c_in) \ 342 { \ 343 UChar c = (UChar)c_in; \ 344 const UChar* char_ptr = s; \ 345 while (1) { \ 346 if (*char_ptr == c) return CONST_CAST(void *,char_ptr); \ 347 char_ptr++; \ 348 } \ 349 } 350 351 GLIBC232_RAWMEMCHR(VG_Z_LIBC_SONAME, rawmemchr) 352 #if defined (VGO_linux) 353 GLIBC232_RAWMEMCHR(VG_Z_LIBC_SONAME, __GI___rawmemchr) 354 #endif 355 356 357 #define STRSTR(soname, fnname) \ 358 char* VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 359 (const char* haystack, const char* needle); \ 360 char* VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 361 (const char* haystack, const char* needle) \ 362 { \ 363 const HChar* h = haystack; \ 364 const HChar* n = needle; \ 365 \ 366 /* find the length of n, not including terminating zero */ \ 367 UWord nlen = 0; \ 368 while (n[nlen]) nlen++; \ 369 \ 370 /* if n is the empty string, match immediately. */ \ 371 if (nlen == 0) return CONST_CAST(HChar *,h); \ 372 \ 373 /* assert(nlen >= 1); */ \ 374 HChar n0 = n[0]; \ 375 \ 376 while (1) { \ 377 const HChar hh = *h; \ 378 if (hh == 0) return NULL; \ 379 if (hh != n0) { h++; continue; } \ 380 \ 381 UWord i; \ 382 for (i = 0; i < nlen; i++) { \ 383 if (n[i] != h[i]) \ 384 break; \ 385 } \ 386 /* assert(i >= 0 && i <= nlen); */ \ 387 if (i == nlen) \ 388 return CONST_CAST(HChar *,h); \ 389 \ 390 h++; \ 391 } \ 392 } 393 394 #if defined(VGO_linux) 395 STRSTR(VG_Z_LIBC_SONAME, strstr) 396 #elif defined(VGO_solaris) 397 STRSTR(VG_Z_LIBC_SONAME, strstr) 398 #endif 399 400 401 #define STRPBRK(soname, fnname) \ 402 char* VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 403 (const char* sV, const char* acceptV); \ 404 char* VG_REPLACE_FUNCTION_ZU(soname,fnname) \ 405 (const char* sV, const char* acceptV) \ 406 { \ 407 const HChar* s = sV; \ 408 const HChar* accept = acceptV; \ 409 \ 410 /* find the length of 'accept', not including terminating zero */ \ 411 UWord nacc = 0; \ 412 while (accept[nacc]) nacc++; \ 413 \ 414 /* if n is the empty string, fail immediately. */ \ 415 if (nacc == 0) return NULL; \ 416 \ 417 /* assert(nacc >= 1); */ \ 418 while (1) { \ 419 UWord i; \ 420 HChar sc = *s; \ 421 if (sc == 0) \ 422 break; \ 423 for (i = 0; i < nacc; i++) { \ 424 if (sc == accept[i]) \ 425 return CONST_CAST(HChar *,s); \ 426 } \ 427 s++; \ 428 } \ 429 \ 430 return NULL; \ 431 } 432 433 #if defined(VGO_linux) 434 STRPBRK(VG_Z_LIBC_SONAME, strpbrk) 435 #elif defined(VGO_solaris) 436 STRPBRK(VG_Z_LIBC_SONAME, strpbrk) 437 #endif 438 439 440 /*--------------------------------------------------------------------*/ 441 /*--- end pc_intercepts.c ---*/ 442 /*--------------------------------------------------------------------*/ 443