1/*
2  This file is part of drd, a thread error detector.
3
4  Copyright (C) 2006-2017 Bart Van Assche <bvanassche@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
45static const HChar* drd_get_error_name(const Error* e);
46
47
48/* Local variables. */
49
50static Bool s_show_conflicting_segments = True;
51
52
53void DRD_(set_show_conflicting_segments)(const Bool scs)
54{
55   s_show_conflicting_segments = scs;
56}
57
58void 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
73void 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 */
94static void print_err_detail(const HChar* format, ...) PRINTF_CHECK(1, 2);
95static 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 */
109static
110void 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 */
130static 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
152static
153void 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)(&sect_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 */
256static 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 */
285static 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. */
299static 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
463static 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 */
508static 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 */
555static
556Bool 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 */
566static 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
572static 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 */
603static
604SizeT 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
612static
613SizeT 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
621static
622void  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. */
628void 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