1 /* 2 This file is part of drd, a thread error detector. 3 4 Copyright (C) 2006-2017 Bart Van Assche <bvanassche (at) acm.org>. 5 6 This program is free software; you can redistribute it and/or 7 modify it under the terms of the GNU General Public License as 8 published by the Free Software Foundation; either version 2 of the 9 License, or (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 19 02111-1307, USA. 20 21 The GNU General Public License is contained in the file COPYING. 22 */ 23 24 25 #include "drd_clientobj.h" /* struct mutex_info */ 26 #include "drd_error.h" 27 #include "drd_malloc_wrappers.h" 28 #include "drd_mutex.h" 29 #include "drd_suppression.h" /* drd_start_suppression() */ 30 #include "pub_drd_bitmap.h" /* LHS_W, ... */ 31 #include "pub_tool_vki.h" 32 #include "pub_tool_basics.h" 33 #include "pub_tool_libcassert.h" /* tl_assert() */ 34 #include "pub_tool_libcbase.h" /* strlen() */ 35 #include "pub_tool_libcprint.h" /* VG_(printf)() */ 36 #include "pub_tool_machine.h" 37 #include "pub_tool_mallocfree.h" /* VG_(malloc), VG_(free) */ 38 #include "pub_tool_options.h" /* VG_(clo_xml) */ 39 #include "pub_tool_threadstate.h" /* VG_(get_pthread_id)() */ 40 #include "pub_tool_tooliface.h" /* VG_(needs_tool_errors)() */ 41 42 43 /* Local function declarations. */ 44 45 static const HChar* drd_get_error_name(const Error* e); 46 47 48 /* Local variables. */ 49 50 static Bool s_show_conflicting_segments = True; 51 52 53 void DRD_(set_show_conflicting_segments)(const Bool scs) 54 { 55 s_show_conflicting_segments = scs; 56 } 57 58 void DRD_(trace_msg)(const HChar* format, ...) 59 { 60 va_list vargs; 61 va_start(vargs, format); 62 if (VG_(clo_xml)) { 63 VG_(printf_xml)(" <trace><text>"); 64 VG_(vprintf_xml)(format, vargs); 65 VG_(printf_xml)("</text></trace>\n"); 66 } else { 67 VG_(vmessage)(Vg_UserMsg, format, vargs); 68 VG_(message)(Vg_UserMsg, "\n"); 69 } 70 va_end(vargs); 71 } 72 73 void DRD_(trace_msg_w_bt)(const HChar* format, ...) 74 { 75 va_list vargs; 76 va_start(vargs, format); 77 if (VG_(clo_xml)) { 78 VG_(printf_xml)(" <trace><text>"); 79 VG_(vprintf_xml)(format, vargs); 80 VG_(printf_xml)("</text>\n"); 81 } else { 82 VG_(vmessage)(Vg_UserMsg, format, vargs); 83 VG_(message)(Vg_UserMsg, "\n"); 84 } 85 VG_(get_and_pp_StackTrace)(VG_(get_running_tid)(), VG_(clo_backtrace_size)); 86 va_end(vargs); 87 if (VG_(clo_xml)) 88 VG_(printf_xml)(" </trace>\n"); 89 } 90 91 /** 92 * Emit error message detail in the format requested by the user. 93 */ 94 static void print_err_detail(const HChar* format, ...) PRINTF_CHECK(1, 2); 95 static void print_err_detail(const HChar* format, ...) 96 { 97 va_list vargs; 98 va_start(vargs, format); 99 if (VG_(clo_xml)) 100 VG_(vprintf_xml)(format, vargs); 101 else 102 VG_(vmessage)(Vg_UserMsg, format, vargs); 103 va_end(vargs); 104 } 105 106 /** 107 * Describe the client address a as good as possible, putting the result in ai. 108 */ 109 static 110 void describe_malloced_addr(Addr const a, AddrInfo* const ai) 111 { 112 Addr heap_block_start; 113 114 if (DRD_(heap_addrinfo)(a, &heap_block_start, &ai->size, &ai->lastchange)) 115 { 116 ai->akind = eMallocd; 117 ai->rwoffset = a - heap_block_start; 118 } 119 else 120 { 121 ai->akind = eUnknown; 122 } 123 } 124 125 /** 126 * Report where a client synchronization object has been observed for the first 127 * time. The printed call stack will either refer to a pthread_*_init() or a 128 * pthread_*lock() call. 129 */ 130 static void first_observed(const Addr obj) 131 { 132 DrdClientobj* cl; 133 134 cl = DRD_(clientobj_get_any)(obj); 135 if (cl) { 136 tl_assert(cl->any.first_observed_at); 137 if (VG_(clo_xml)) { 138 print_err_detail(" <first_observed_at>\n" 139 " <what>%pS</what>\n" 140 " <address>0x%lx</address>\n", 141 DRD_(clientobj_type_name)(cl->any.type), obj); 142 VG_(pp_ExeContext)(cl->any.first_observed_at); 143 print_err_detail(" </first_observed_at>\n"); 144 } else { 145 print_err_detail("%s 0x%lx was first observed at:\n", 146 DRD_(clientobj_type_name)(cl->any.type), obj); 147 VG_(pp_ExeContext)(cl->any.first_observed_at); 148 } 149 } 150 } 151 152 static 153 void drd_report_data_race(const Error* const err, 154 const DataRaceErrInfo* const dri) 155 { 156 const Bool xml = VG_(clo_xml); 157 const HChar* const what_prefix = xml ? " <what>" : ""; 158 const HChar* const what_suffix = xml ? "</what>" : ""; 159 const HChar* const auxwhat_prefix = xml ? " <auxwhat>" : ""; 160 const HChar* const auxwhat_suffix = xml ? "</auxwhat>" : ""; 161 const HChar* const indent = xml ? " " : ""; 162 AddrInfo ai; 163 164 XArray* /* of HChar */ descr1 165 = VG_(newXA)( VG_(malloc), "drd.error.drdr2.1", 166 VG_(free), sizeof(HChar) ); 167 XArray* /* of HChar */ descr2 168 = VG_(newXA)( VG_(malloc), "drd.error.drdr2.2", 169 VG_(free), sizeof(HChar) ); 170 171 tl_assert(dri); 172 tl_assert(dri->addr); 173 tl_assert(dri->size > 0); 174 175 (void) VG_(get_data_description)(descr1, descr2, dri->addr); 176 /* If there's nothing in descr1/2, free them. Why is it safe to 177 VG_(indexXA) at zero here? Because VG_(get_data_description) 178 guarantees to zero terminate descr1/2 regardless of the outcome 179 of the call. So there's always at least one element in each XA 180 after the call. 181 */ 182 if (0 == VG_(strlen)( VG_(indexXA)( descr1, 0 ))) { 183 VG_(deleteXA)( descr1 ); 184 descr1 = NULL; 185 } 186 if (0 == VG_(strlen)( VG_(indexXA)( descr2, 0 ))) { 187 VG_(deleteXA)( descr2 ); 188 descr2 = NULL; 189 } 190 /* Assume (assert) that VG_(get_data_description) fills in descr1 191 before it fills in descr2 */ 192 if (descr1 == NULL) 193 tl_assert(descr2 == NULL); 194 /* So anyway. Do we have something useful? */ 195 if (descr1 == NULL) 196 { 197 /* No. Do Plan B. */ 198 describe_malloced_addr(dri->addr, &ai); 199 } 200 201 print_err_detail("%sConflicting %s by thread %u at 0x%08lx size %lu%s\n", 202 what_prefix, dri->access_type == eStore ? "store" : "load", 203 dri->tid, dri->addr, dri->size, what_suffix); 204 205 VG_(pp_ExeContext)(VG_(get_error_where)(err)); 206 if (descr1 != NULL) { 207 print_err_detail("%s%s\n", indent, (HChar*)VG_(indexXA)(descr1, 0)); 208 if (descr2 != NULL) 209 print_err_detail("%s%s\n", indent, (HChar*)VG_(indexXA)(descr2, 0)); 210 } else if (ai.akind == eMallocd && ai.lastchange) { 211 print_err_detail("%sAddress 0x%lx is at offset %ld from 0x%lx.%s%s", 212 auxwhat_prefix, dri->addr, ai.rwoffset, 213 dri->addr - ai.rwoffset, auxwhat_suffix, 214 xml ? "\n" : ""); 215 if (xml) 216 print_err_detail(" <allocation_context>\n"); 217 else 218 print_err_detail(" Allocation context:\n"); 219 VG_(pp_ExeContext)(ai.lastchange); 220 if (xml) 221 print_err_detail(" </allocation_context>\n"); 222 } else { 223 const HChar *sect_name; 224 VgSectKind sect_kind; 225 226 sect_kind = VG_(DebugInfo_sect_kind)(§_name, dri->addr); 227 if (sect_kind != Vg_SectUnknown) { 228 print_err_detail("%sAllocation context: %ps section of %ps%s\n", 229 auxwhat_prefix, VG_(pp_SectKind)(sect_kind), 230 sect_name, auxwhat_suffix); 231 } else { 232 print_err_detail("%sAllocation context: unknown.%s\n", 233 auxwhat_prefix, auxwhat_suffix); 234 } 235 } 236 if (s_show_conflicting_segments) 237 { 238 DRD_(thread_report_conflicting_segments)(dri->tid, 239 dri->addr, dri->size, 240 dri->access_type); 241 } 242 243 if (descr2) 244 VG_(deleteXA)(descr2); 245 if (descr1) 246 VG_(deleteXA)(descr1); 247 } 248 249 /** 250 * Compare two error contexts. The core function VG_(maybe_record_error)() 251 * calls this function to compare error contexts such that errors that occur 252 * repeatedly are only printed once. This function is only called by the core 253 * if the error kind of e1 and e2 matches and if the ExeContext's of e1 and 254 * e2 also match. 255 */ 256 static Bool drd_compare_error_contexts(VgRes res, const Error* e1, 257 const Error* e2) 258 { 259 tl_assert(VG_(get_error_kind)(e1) == VG_(get_error_kind)(e2)); 260 261 switch (VG_(get_error_kind)(e1)) 262 { 263 case DataRaceErr: 264 { 265 const DataRaceErrInfo* const dri1 = VG_(get_error_extra)(e1); 266 const DataRaceErrInfo* const dri2 = VG_(get_error_extra)(e2); 267 return dri1->access_type == dri2->access_type 268 && dri1->size == dri2->size; 269 } 270 case MutexErr: 271 { 272 const MutexErrInfo* const mei1 = VG_(get_error_extra)(e1); 273 const MutexErrInfo* const mei2 = VG_(get_error_extra)(e2); 274 return mei1->mutex == mei2->mutex; 275 } 276 default: 277 return True; 278 } 279 } 280 281 /** 282 * Called by the core just before an error message will be printed. Used by 283 * DRD to print the thread number as a preamble. 284 */ 285 static void drd_tool_error_before_pp(const Error* const e) 286 { 287 static DrdThreadId s_last_tid_printed = 1; 288 DrdThreadId* err_extra; 289 290 err_extra = VG_(get_error_extra)(e); 291 292 if (err_extra && *err_extra != s_last_tid_printed && !VG_(clo_xml)) { 293 VG_(umsg)("%s:\n", DRD_(thread_get_name)(*err_extra)); 294 s_last_tid_printed = *err_extra; 295 } 296 } 297 298 /** Report an error to the user. */ 299 static void drd_tool_error_pp(const Error* const e) 300 { 301 const Bool xml = VG_(clo_xml); 302 const HChar* const what_prefix = xml ? " <what>" : ""; 303 const HChar* const what_suffix = xml ? "</what>" : ""; 304 305 if (xml) 306 VG_(printf_xml)( " <kind>%pS</kind>\n", drd_get_error_name(e)); 307 308 switch (VG_(get_error_kind)(e)) 309 { 310 case DataRaceErr: { 311 drd_report_data_race(e, VG_(get_error_extra)(e)); 312 break; 313 } 314 case MutexErr: { 315 MutexErrInfo* p = (MutexErrInfo*)(VG_(get_error_extra)(e)); 316 tl_assert(p); 317 if (p->recursion_count >= 0) { 318 print_err_detail("%s%s: mutex 0x%lx, recursion count %d, owner %u." 319 "%s\n", what_prefix, VG_(get_error_string)(e), 320 p->mutex, p->recursion_count, p->owner, what_suffix); 321 } else { 322 print_err_detail("%sThe object at address 0x%lx is not a mutex.%s\n", 323 what_prefix, p->mutex, what_suffix); 324 } 325 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 326 first_observed(p->mutex); 327 break; 328 } 329 case CondErr: { 330 CondErrInfo* cdei =(CondErrInfo*)(VG_(get_error_extra)(e)); 331 print_err_detail("%s%s: cond 0x%lx%s\n", what_prefix, 332 VG_(get_error_string)(e), cdei->cond, what_suffix); 333 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 334 first_observed(cdei->cond); 335 break; 336 } 337 case CondDestrErr: { 338 CondDestrErrInfo* cdi = (CondDestrErrInfo*)(VG_(get_error_extra)(e)); 339 print_err_detail("%s%s: cond 0x%lx, mutex 0x%lx locked by thread %u%s\n", 340 what_prefix, VG_(get_error_string)(e), cdi->cond, 341 cdi->mutex, cdi->owner, what_suffix); 342 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 343 first_observed(cdi->mutex); 344 break; 345 } 346 case CondRaceErr: { 347 CondRaceErrInfo* cei = (CondRaceErrInfo*)(VG_(get_error_extra)(e)); 348 print_err_detail("%sProbably a race condition: condition variable 0x%lx" 349 " has been signaled but the associated mutex 0x%lx is" 350 " not locked by the signalling thread.%s\n", 351 what_prefix, cei->cond, cei->mutex, what_suffix); 352 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 353 first_observed(cei->cond); 354 first_observed(cei->mutex); 355 break; 356 } 357 case CondWaitErr: { 358 CondWaitErrInfo* cwei = (CondWaitErrInfo*)(VG_(get_error_extra)(e)); 359 print_err_detail("%s%s: condition variable 0x%lx, mutexes 0x%lx and" 360 " 0x%lx%s\n", what_prefix, VG_(get_error_string)(e), 361 cwei->cond, cwei->mutex1, cwei->mutex2, what_suffix); 362 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 363 first_observed(cwei->cond); 364 first_observed(cwei->mutex1); 365 first_observed(cwei->mutex2); 366 break; 367 } 368 case SemaphoreErr: { 369 SemaphoreErrInfo* sei = (SemaphoreErrInfo*)(VG_(get_error_extra)(e)); 370 tl_assert(sei); 371 print_err_detail("%s%s: semaphore 0x%lx%s\n", what_prefix, 372 VG_(get_error_string)(e), sei->semaphore, what_suffix); 373 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 374 first_observed(sei->semaphore); 375 break; 376 } 377 case BarrierErr: { 378 BarrierErrInfo* bei = (BarrierErrInfo*)(VG_(get_error_extra)(e)); 379 tl_assert(bei); 380 print_err_detail("%s%s: barrier 0x%lx%s\n", what_prefix, 381 VG_(get_error_string)(e), bei->barrier, what_suffix); 382 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 383 if (bei->other_context) { 384 if (xml) 385 print_err_detail(" <confl_wait_call>\n"); 386 print_err_detail("%sConflicting wait call by thread %u:%s\n", 387 what_prefix, bei->other_tid, what_suffix); 388 VG_(pp_ExeContext)(bei->other_context); 389 if (xml) 390 print_err_detail(" </confl_wait_call>\n"); 391 } 392 first_observed(bei->barrier); 393 break; 394 } 395 case RwlockErr: { 396 RwlockErrInfo* p = (RwlockErrInfo*)(VG_(get_error_extra)(e)); 397 tl_assert(p); 398 print_err_detail("%s%s: rwlock 0x%lx.%s\n", what_prefix, 399 VG_(get_error_string)(e), p->rwlock, what_suffix); 400 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 401 first_observed(p->rwlock); 402 break; 403 } 404 case HoldtimeErr: { 405 HoldtimeErrInfo* p =(HoldtimeErrInfo*)(VG_(get_error_extra)(e)); 406 tl_assert(p); 407 tl_assert(p->acquired_at); 408 if (xml) 409 print_err_detail(" <acquired_at>\n"); 410 else 411 print_err_detail("Acquired at:\n"); 412 VG_(pp_ExeContext)(p->acquired_at); 413 if (xml) 414 print_err_detail(" </acquired_at>\n"); 415 print_err_detail("%sLock on %s 0x%lx was held during %u ms" 416 " (threshold: %u ms).%s\n", what_prefix, 417 VG_(get_error_string)(e), p->synchronization_object, 418 p->hold_time_ms, p->threshold_ms, what_suffix); 419 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 420 first_observed(p->synchronization_object); 421 break; 422 } 423 case GenericErr: { 424 GenericErrInfo* gei = (GenericErrInfo*)(VG_(get_error_extra)(e)); 425 print_err_detail("%s%s%s\n", what_prefix, VG_(get_error_string)(e), 426 what_suffix); 427 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 428 if (gei->addr) 429 first_observed(gei->addr); 430 break; 431 } 432 case InvalidThreadId: { 433 InvalidThreadIdInfo* iti =(InvalidThreadIdInfo*)(VG_(get_error_extra)(e)); 434 print_err_detail("%s%s 0x%llx%s\n", what_prefix, VG_(get_error_string)(e), 435 iti->ptid, what_suffix); 436 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 437 break; 438 } 439 case UnimpHgClReq: { 440 UnimpClReqInfo* uicr =(UnimpClReqInfo*)(VG_(get_error_extra)(e)); 441 print_err_detail("%sThe annotation macro %s has not yet been implemented" 442 " in %ps%s\n", what_prefix, uicr->descr, 443 "<valgrind/helgrind.h>", what_suffix); 444 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 445 break; 446 } 447 case UnimpDrdClReq: { 448 UnimpClReqInfo* uicr =(UnimpClReqInfo*)(VG_(get_error_extra)(e)); 449 print_err_detail("%sThe annotation macro %s has not yet been implemented" 450 " in %ps%s\n", what_prefix, uicr->descr, 451 "<valgrind/drd.h>", what_suffix); 452 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 453 break; 454 } 455 default: 456 print_err_detail("%s%s%s\n", what_prefix, VG_(get_error_string)(e), 457 what_suffix); 458 VG_(pp_ExeContext)(VG_(get_error_where)(e)); 459 break; 460 } 461 } 462 463 static UInt drd_tool_error_update_extra(const Error* e) 464 { 465 switch (VG_(get_error_kind)(e)) 466 { 467 case DataRaceErr: 468 return sizeof(DataRaceErrInfo); 469 case MutexErr: 470 return sizeof(MutexErrInfo); 471 case CondErr: 472 return sizeof(CondErrInfo); 473 case CondDestrErr: 474 return sizeof(CondDestrErrInfo); 475 case CondRaceErr: 476 return sizeof(CondRaceErrInfo); 477 case CondWaitErr: 478 return sizeof(CondWaitErrInfo); 479 case SemaphoreErr: 480 return sizeof(SemaphoreErrInfo); 481 case BarrierErr: 482 return sizeof(BarrierErrInfo); 483 case RwlockErr: 484 return sizeof(RwlockErrInfo); 485 case HoldtimeErr: 486 return sizeof(HoldtimeErrInfo); 487 case GenericErr: 488 return sizeof(GenericErrInfo); 489 case InvalidThreadId: 490 return sizeof(InvalidThreadIdInfo); 491 case UnimpHgClReq: 492 return sizeof(UnimpClReqInfo); 493 case UnimpDrdClReq: 494 return sizeof(UnimpClReqInfo); 495 default: 496 tl_assert(False); 497 break; 498 } 499 } 500 501 /** 502 * Parse suppression name. 503 * 504 * The suppression types recognized by DRD are the same types as the error 505 * types supported by DRD. So try to match the suppression name against the 506 * names of DRD error types. 507 */ 508 static Bool drd_is_recognized_suppression(const HChar* const name, 509 Supp* const supp) 510 { 511 DrdErrorKind skind = 0; 512 513 if (VG_(strcmp)(name, STR_DataRaceErr) == 0) 514 skind = DataRaceErr; 515 else if (VG_(strcmp)(name, STR_MutexErr) == 0) 516 skind = MutexErr; 517 else if (VG_(strcmp)(name, STR_CondErr) == 0) 518 skind = CondErr; 519 else if (VG_(strcmp)(name, STR_CondDestrErr) == 0) 520 skind = CondDestrErr; 521 else if (VG_(strcmp)(name, STR_CondRaceErr) == 0) 522 skind = CondRaceErr; 523 else if (VG_(strcmp)(name, STR_CondWaitErr) == 0) 524 skind = CondWaitErr; 525 else if (VG_(strcmp)(name, STR_SemaphoreErr) == 0) 526 skind = SemaphoreErr; 527 else if (VG_(strcmp)(name, STR_BarrierErr) == 0) 528 skind = BarrierErr; 529 else if (VG_(strcmp)(name, STR_RwlockErr) == 0) 530 skind = RwlockErr; 531 else if (VG_(strcmp)(name, STR_HoldtimeErr) == 0) 532 skind = HoldtimeErr; 533 else if (VG_(strcmp)(name, STR_GenericErr) == 0) 534 skind = GenericErr; 535 else if (VG_(strcmp)(name, STR_InvalidThreadId) == 0) 536 skind = InvalidThreadId; 537 else if (VG_(strcmp)(name, STR_UnimpHgClReq) == 0) 538 skind = UnimpHgClReq; 539 else if (VG_(strcmp)(name, STR_UnimpDrdClReq) == 0) 540 skind = UnimpDrdClReq; 541 else 542 return False; 543 544 VG_(set_supp_kind)(supp, skind); 545 return True; 546 } 547 548 /** 549 * Read additional suppression information from the suppression file. 550 * 551 * None of the suppression patterns recognized by DRD has 'extra' lines 552 * of information in the suppression file, so just return True to indicate 553 * that reading the 'extra' lines succeeded. 554 */ 555 static 556 Bool drd_read_extra_suppression_info(Int fd, HChar** bufpp, 557 SizeT* nBufp, Int* lineno, Supp* supp) 558 { 559 return True; 560 } 561 562 /** 563 * Determine whether or not the types of the given error message and the 564 * given suppression match. 565 */ 566 static Bool drd_error_matches_suppression(const Error* const e, 567 const Supp* const supp) 568 { 569 return VG_(get_supp_kind)(supp) == VG_(get_error_kind)(e); 570 } 571 572 static const HChar* drd_get_error_name(const Error* e) 573 { 574 switch (VG_(get_error_kind)(e)) 575 { 576 case DataRaceErr: return VGAPPEND(STR_, DataRaceErr); 577 case MutexErr: return VGAPPEND(STR_, MutexErr); 578 case CondErr: return VGAPPEND(STR_, CondErr); 579 case CondDestrErr: return VGAPPEND(STR_, CondDestrErr); 580 case CondRaceErr: return VGAPPEND(STR_, CondRaceErr); 581 case CondWaitErr: return VGAPPEND(STR_, CondWaitErr); 582 case SemaphoreErr: return VGAPPEND(STR_, SemaphoreErr); 583 case BarrierErr: return VGAPPEND(STR_, BarrierErr); 584 case RwlockErr: return VGAPPEND(STR_, RwlockErr); 585 case HoldtimeErr: return VGAPPEND(STR_, HoldtimeErr); 586 case GenericErr: return VGAPPEND(STR_, GenericErr); 587 case InvalidThreadId: return VGAPPEND(STR_, InvalidThreadId); 588 case UnimpHgClReq: return VGAPPEND(STR_, UnimpHgClReq); 589 case UnimpDrdClReq: return VGAPPEND(STR_, UnimpDrdClReq); 590 default: 591 tl_assert(0); 592 } 593 return 0; 594 } 595 596 /** 597 * Return extra suppression information. 598 * 599 * Invoked while printing a suppression pattern because the user 600 * specified --gen-suppressions=yes or all on the command line. DRD does not 601 * define any 'extra' suppression information. 602 */ 603 static 604 SizeT drd_get_extra_suppression_info(const Error* e, 605 /*OUT*/HChar* buf, Int nBuf) 606 { 607 tl_assert(nBuf >= 1); 608 buf[0] = '\0'; 609 return 0; 610 } 611 612 static 613 SizeT drd_print_extra_suppression_use(const Supp* su, 614 /*OUT*/HChar* buf, Int nBuf) 615 { 616 tl_assert(nBuf >= 1); 617 buf[0] = '\0'; 618 return 0; 619 } 620 621 static 622 void drd_update_extra_suppresion_use(const Error* e, const Supp* supp) 623 { 624 return; 625 } 626 627 /** Tell the Valgrind core about DRD's error handlers. */ 628 void DRD_(register_error_handlers)(void) 629 { 630 VG_(needs_tool_errors)(drd_compare_error_contexts, 631 drd_tool_error_before_pp, 632 drd_tool_error_pp, 633 False, 634 drd_tool_error_update_extra, 635 drd_is_recognized_suppression, 636 drd_read_extra_suppression_info, 637 drd_error_matches_suppression, 638 drd_get_error_name, 639 drd_get_extra_suppression_info, 640 drd_print_extra_suppression_use, 641 drd_update_extra_suppresion_use); 642 } 643
